1.Collection与Collections的区别？

 1)Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。实现该接口的类主要有List和Set，该接口的设计目标是为了各种具体的集合提供最大化的统一的操作方式。
  2)Collections是针对集合类的一个包裹类，它提供了一系列静态方法实现对各种集合的搜索、排序以及线程安全化等操作

reverse(List list):反转list中的顺序，sort(List list):对list中的顺序进行自然排序，升序

2.object的常见方法

clone(),toString(),equals(),hashcode(),wait,notify(),notifyAll()

1)实现了listIterator接口和Iterator接口，可以用迭代器来进行打印；

   List<String> list=new ArrayList<>();
      list.add("123");
      list.add("456");
      list.add("hello");
   ListIterator<String> sb=list.listIterator();
   while(sb.hasNext())
   {
      System.out.println(sb.next());
   }
我们也可以通过for循环的方式或者for each的方式来进行打印
 List<String> list=new ArrayList<>();
   list.add("123");
   list.add("456");
   list.add("789");
   for(String x:list)
   {
      System.out.println(x);
   }
   System.out.println(list);
   for(int i=0;i<list.size();i++)
   {
      System.out.println(list.get(i));
   }

2)我们在使用remove()方法的时候要注意什么?

 List<String> list=new ArrayList<>();
   list.add("abc");
   list.add("cde");
   list.add("hello");
   Iterator<String> it= list.iterator();
   while(it.hasNext())
   {
      it.remove();
      System.out.println(it.next());
   }
//  String ret= it.next();
     if(ret.equals("hello"))
     {
        it.remove();
     }else
     {
        System.out.println(it.next());
     }

3)在调用remove()方法的时候，搭配迭代器进行使用的时候，应先获取到迭代器中的元素，再根据我们所指定的条件进行删除，否则上面的代码可能会出现java.lang.lllegalStateException异常

boolean add---->进行尾插
add(int index,E element),把E插到index位置
boolean addAll(Collection<? extends E> c)尾插c中的元素
E remove(int index) 删除index位置的元素
boolean remove(Object o) 删除第一次出现的o
E get(int index)找到index位置的元素
E set(int index,E element) 将下标index位置元素设置成element
void clear()清空
boolean contains(Object o)判断元素o是否在线性表中
int indexOf(Object o) 返回第一个o所在的下标
int latIndexOf(Object o)返回最后一个o所在的下标
List subList(int fromindex,int toindex)进行截取

4)ArrayLIst的扩容机制

1）当new ArrayList<>()没有指定容量大小的时候，底层虽然是数组，但是数组的大小是0;

2)当第一次add的时候，整个顺序表的长度才变成了10，当这10个位置放满了之后，就开始进行扩容，每次以当前长度1.5倍进行扩容

3)如果当前在构造方法中指定容量,那么顺序表的大小就是给定容量的大小,如果放满了，还是以1.5倍进行扩容;

5)ArrayList的构造方法

1)ArrayLIst();无参数进行构造 

2)ArrayList(Collection <? extends E> c)利用其它的Colleection来对ArrayList来进行构造

3)ArrayList(int index),根据顺序表来进行指定容量

List<String> list1=new ArrayList<>();
list1.add("123");
list1.add("456");
List<String> list2=new ArrayList<>(list1);
System.out.println(list2);
tolowerCase是返回了一个新的对象,java中由编译器自动导入,而不需要手动import导入的包是java.lang,以.java为后缀的源文件,只能有一个与源文件相同的类,可以包含其他类;

练习题一：输入:str1=abcqweracb 输出:abcqwer

先创建出一个StringBuilder对象,再进行遍历str这个字符串里面的字符,如果里面有str1中的字符，就不会进行放入，如果没有，就进行放入;

 public static void main(String[] args) {
      Scanner scan=new Scanner(System.in);
      String str=scan.next();
     StringBuilder sb=new StringBuilder();
   for(int i=0;i<str.length();i++)
   {    char ch=str.charAt(i);
      if(!sb.toString().contains(ch+""))
      {
         sb.append(ch);
      }
   }
   System.out.println(sb.toString());

   }

 练习题二:一个学校中有若干学生(学生对象放在一个List中，每一个学生有一个姓名，班级，和考试成绩的属性，某次考试成绩结束之后，每一个学生都获得了一个考试成绩.遍历List集合,把每一个学生对象的属性都打印出来；

List是可以存放自定义类型的
class Student{
   String name;
   String classes;
   double score;

   public Student(String name, String classes, double score) {
      this.name = name;
      this.classes = classes;
      this.score = score;
   }

   @Override
   public String toString() {
      return "Student{" +
              "name='" + name + '\'' +
              ", classes='" + classes + '\'' +
              ", score=" + score +
              '}';
   }
}
class test {
   public static void main(String[] args) {
      List<Student> list=new ArrayList<>();
      list.add(new Student("bit1","java100",90.3));
      list.add(new Student("bit2","java101",100.5));
      list.add(new Student("bit3","java102",31.7));
      System.out.println(list);

   }

练习题三:删除第一个字符串中出现的第二个字符串中的字符；例如 String str1=" welcome to bit"; String str2="come" 输出的结果是wl t bit

我们可以使用一个集合类list来进行操作,我们使用for循环进行循环遍历str1中的字符串中的字符，如果str2不包含着这个字符，那么就可以把这个放到List中，最终打印我的这个List即可

在这里面我们要注意一个事情,contains(里面放的是字符串类型而不是字符类型)
String str1="welcome to bit";
     String str2="come";
     ArrayList<Character> list=new ArrayList<>();
     for(int i=0;i<str1.length();i++)
     {   char ch=str1.charAt(i);
        if(!str2.contains(ch+""))
        {
           list.add(ch);
        }
     }
     System.out.println(list);
   }

练习题四:有一个List当前存放的是整形的数据，运用Collections.sort对list进行排序

 ArrayList<Integer> list=new ArrayList<>();
      list.add(10);
      list.add(11);
      list.add(7);
      Collections.sort(list);
      System.out.println(list);

练习题五:实现一个扑克牌的功能

1)一张扑克牌就是一个对象，我们使用Card对象来进行描述一张牌

2)我们在使用一个Box对象来进行描述一副牌

3)在Box对象里面,我们定义一个全局变量的String数组来描述花色

通过BuyCard方法来进行买一符牌，生成一副牌，我们还要创建一个List表来存放所有的扑克牌

4)洗牌的过程:假设我有100张牌,我想洗最后一张牌，就随机生成前面的一张牌进行交换，我从后面向前面进行遍历,我可以Random random=new Random(); int index=random.nextInt(100),我想办法生成一个0-100的下标，将这个100的下标与前面的牌进行交换；

class Card{
   private int rank;
   private String suit;
   public Card(int rank,String suit)
   {
      this.rank=rank;
      this.suit=suit;
   }
   public String toString()
   {
      return "[数值是"+rank+" "+"花色是"+suit+"]";
   }

}
class Box{
   private static final String[] suits={"♥","♠","♣","♦"};

   public static List<Card> BuyCard()
   {    List<Card> desk=new ArrayList<>();
      //我们接下来想用两层循环做到每一个花色生成13张牌
       for(int i=0;i<4;i++)//外层循环表示花色,i是可以从0下标开始进行的,因为他这个下标的意义是去除数组里面的元素
       {
          for(int j=1;j<=13;j++)
          {
               String suit=suits[i];
               int rank=j;
               Card card=new Card(rank,suit);
               desk.add(card);//设置属性,构造牌，并把排放到list里面
          }
       }
       return desk;
   }
   //下一个方法我们要进行洗牌,使用洗牌的这个方法的时候,我们要把List传递过去，才可以进行正式的洗牌
   public static void xipai(List<Card> desk)
   {  int len=desk.size();
      for(int i=len-1;i>0;i--)
      {
         Random random=new Random();
         int index=random.nextInt(i);
         swap(desk,index,i);
      }
   }
   public static void swap(List<Card> list,int index,int i)
   {
      Card temp=list.get(i);
      list.set(i,list.get(index));
      list.set(index,temp);
   }
}
     List<Card> list=Box.BuyCard();
         Box.xipai(list);
         System.out.println(list);

在下面我们还要实现揭牌和玩牌的操作

1)每一个人要轮流揭5张牌,我们把每一个人所揭的牌都放到一个List数组里面

2）我们在实现一个List<List<card>>来方便进行管理

3)揭牌三个人轮流揭5张牌

4)拿到Box里面的牌,调用remove(0)方法即可

   List<Card> list=Box.BuyCard();
     System.out.println("开始进行买牌");
     System.out.println("开始进行洗牌");
         Box.xipai(list);
     System.out.println("开始进行玩牌和揭牌");
     List<Card> hand1=new ArrayList<>();
     List<Card> hand2=new ArrayList<>();
     List<Card> hand3=new ArrayList<>();
     List<List<Card>> hand=new ArrayList<>();
     hand.add(hand1);
     hand.add(hand2);
     hand.add(hand3);
     for(int i=0;i<5;i++)//三个人论流揭牌5张
     {
        for(int j=0;j<3;j++)
        {
           Card card=list.remove(i);
           hand.get(j).add(card);
        }
     }
     System.out.println("第一个人的牌"+hand1);
      System.out.println("第二个人的牌"+hand2);
      System.out.println("第三个人的牌"+hand3);
      System.out.println("剩下的牌"+list);
   }
//上面的循环不可以写成这样
for(int i=0;i<3;i++){
for(int j=0;j<5;j++){
}
}
//这就表示每一个人一下子揭5张牌

 练习题六:实现一个杨辉三角

1
1 2 1
1 3 3 1
1 4 6 4 1
arr1[i][j]=arr1[i-1][j-1]+arr1[i-1][j],我们可以把每一行看成一个List

 public static void main(String[] args) {
      Scanner scanner=new Scanner(System.in);
      int n= scanner.nextInt();
  List<List<Integer>> ret=new ArrayList<>();
  List<Integer> list1=new ArrayList<>();
  //1我们先进行处理第一行
      list1.add(1);
      ret.add(list1);//到这里面我们才处理完杨辉三角的第一行
      for(int i=1;i<n;i++)//现在外层循环用来处理每一行
      {
       //每一行的第一个数字都是1,所以下面处理的是每一行的第一个数字
         List<Integer> list=new ArrayList();
         list.add(1);
         List<Integer> prev=ret.get(i-1);
         for(int j=1;j<i;j++)
         {
            int num=prev.get(j)+prev.get(j-1);
            list.add(num);
         }
         //处理每一行的结尾
         list.add(1);
         ret.add(list);
      }
      System.out.println(ret);
   }