今日复习day05

 //注意：Collection是一个接口
//确认一下collection集合的特点：单列集合，每个元素只包含一个值
 //list集合：有序 可重复 有索引
 //Arraylist,Linekdlist

 ArrayList<String> list=new ArrayList<>();//有序 可重复 有索引

/set集合：无序 不重复 无索引
//hashSet：无序 不重复 无索引
//LinkedHashSet:有序 不重复 无索引
//Tree:按照大小进行默认升序排列
HashSet<String> set=new HashSet<>();//无序 不重复 无索引
set.add("java1");
set.add("java2");
set.add("java3");
System.out.println(set);

//Collection的常用方法
        Collection<String> c=new ArrayList<>();//这是一个多态的写法
        //1.add() :添加元素，成功了返回true
        c.add("java1");
        c.add("java1");
        c.add("java2");
        System.out.println(c);
        //2.clear():清空集合的元素
//        c.clear();
//        System.out.println(c);
        //3.isEmpty():判断集合是否为空，是的话返回true
        System.out.println(c.isEmpty());
        //4.size():返回元素的大小
        System.out.println(c.size());
        //5.contain():判断集合是否包含某个元素
        System.out.println(c.contains("java1"));
        //6.remove():删除某个元素，如果有多个重复的元素默认删除第一个
        System.out.println(c.remove("java1"));
        System.out.println(c);
        //7.toArray():把集合转化成数组
        Object[]arr=c.toArray();
        System.out.println(Arrays.toString(arr));
        //Object[]a=c.toArray();
         //可以指定转化
        String[]arr2=c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(arr2));
        System.out.println("----------------------------");
        //8。addall()把一个集合的数据全部倒入另一个集合
        Collection<String> c1=new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2=new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);//将c2的数据复制了一份到入c1里面

//使用迭代器遍历集合

Collection<String> c=new ArrayList<>();
c.add("小明");
c.add("哈哈");
c.add("后收费的");
//1.从集合对象中获取迭代器对象
Iterator<String> s=c.iterator();

2.我们因该使用循环结合迭代器来遍历集合
 while (s.hasNext()){//判断当前位置是否有集合
     System.out.println(s.next());

 }

//使用增强for遍历元素集合

//for(数据类型   变量名：数组名或集合名)
for (String cle:c){
    System.out.println(cle);
String name[]= {"按规划", "还是被"};
    for (String s : name) {
        System.out.println(s);
    }

//forEach ():结合lamda表达式遍历集合
//用lamda表达式进行简化
c.forEach((String s) ->{
        System.out.println(s);

});
c.forEach( s->System.out.println(s));//因为前后传入的参数一样，可以简化成方法的调用c.forEach( System.out::println);

//linkedlist基于链表实现的
//集合查询慢，删除和添加数据较快,特别是首尾元素

//多用于队列(先进先出)的形式（需要平凡的进行首尾的数据处理）
//入列
LinkedList<String> s=new LinkedList<>();
s.addLast("贺卡收到回复");

//出列
System.out.println(s.removeFirst());

//入栈（push）
s.push("洒家扩大");

//出栈(pop)
System.out.println(s.pop());

 //list集合的特点和方法:有序 可重复 有索引
  List<String>  list=new ArrayList<>();//
  list.add("知书经");
  list.add("哈哈哈");
  list.add("啊哈哈哈");
  System.out.println(list);
///1.add(int index,E elment):在某个索引位置插入元素
    list.add(1,"哈哈哈是否是");
  System.out.println(list);
  //2.remove():删除索引处的元素，并返回删除的元素
//  list.remove(1);
  System.out.println(list.remove(1));
  System.out.println(list);
 //3.get():返回集合中指定元素
  System.out.println(list.get(1));
 //4.set():修改指定位置的元素值，并返回原来的元素
  System.out.println(list.set(2, "合法哦"));
  System.out.println(list);

//list集合的遍历方式
List<String>list=new ArrayList<>();
list.add("黑暗势力飞洒");
list.add("含税单价");
list.add("的深刻思考");

//for循环
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

//2.迭代器
Iterator<String> s=list.iterator();
while (s.hasNext()){
    System.out.println(s.next());
}

//3.增强for循环
for (String s1 : list) {
    System.out.println(s1);
}
//4.lamda表达式
list.forEach(s2->{
    System.out.println(s2);
});

 //hashSet：无序 不重复 无索引
   //hashSet的底层原理，基于哈希表：数组+链表，红黑树
//哈希值：是一个int类型的数值，java中的每个对象都以有一个哈希值
//同一个对象调用哈希值是相同的
//不同的对象，哈希值可能相同

//1.创建一个linkedhashset集合的对象
Set<Integer> set=new LinkedHashSet<>();//LinkedSet: 有序 不重复 无索引
//LinkedhashSet:基于哈希表（数组，链表，红黑树）实现的
//他的每个元素都多了一个双链表来记录他前后元素的位置
set.add(666666);
set.add(8888);

//1.创建一个set集合的对象
   //set的是一个接口
   //Set<Integer> set=new HashSet<>();//Hashset :无序(只会无序一次) 不重复 无索引
   Set<Integer> set=new LinkedHashSet<>();//LinkedSet: 有序 不重复 无索引
//   Set<Integer>set=new TreeSet<>();//TreeSet:可排序（从小到大）  不重复 无索引

重写比较方法

public class Student implements Comparable<Student> {

@Override
public int compareTo(Student o) {
    //左边大于右边对象返回正整数
    //左边小于右边对象返回负整数
    //左边等于右边对象返回0
    return this.age-o.age;
}

//掌握treeSet集合使用:不重复 无索引 可排序（按照元素的从小到大进行排序）
//底层是基于红黑树排序
//注意：
//对于数值类型：Interger,Double,进行大小排
//字符串：默认按照首字符排
//对于自定义对象，默认无法排
Set<Integer> s=new java.util.TreeSet<>();
s.add(1);
s.add(3);

//2.通过Tree的集合有参构造器来调用compare对象
Set<Student> students=new java.util.TreeSet<>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return Double.compare(o1.getHeight(),o2.getHeight());
    }
});

/理解集合并发的修改异常问题
        List<String> list=new ArrayList<>();
        list.add("花蛤还是");
        list.add("安徽看很久");
        list.add("爱护环境更加");
        list.add("哈克很快就");
        list.add("哈克很快就");
        System.out.println(list);
        //遍历集合全部数据，并从集合删除
         Iterator<String> it=list.iterator();
        while (it.hasNext()){
            String name= it.next();
            if (name.contains("很")){
               // list.remove(name);//并发起异常的错误
                it.remove();//删除迭代器当前遍历到的数据，同时每删除一个数据，相当于在底层做了i--
            }
        }
        System.out.println(list);
//        for (int i = 0; i < list.size(); i++) {
//           if (list.get(i).contains("很")){
//               list.remove(i);
//               i--;
//           }
//        }
//        System.out.println(list);

        //使用增强for来遍历集合，删除元素的数据，会出bug，并且无法解决
//       for (String name : list) {
//            if (name.contains("很")){
//                list.remove(name);
//            }
//        }
//        System.out.println(list);


        //使用lamda表达式本质还是和增强for一样
       // list.forEach(name-> {
//            if (name.contains("很")){
//                list.remove(name);
//            }
//        });
//        System.out.println(list);

//掌握Collection的工具类的使用
//1.addAll(集合,添加的数据):为集合添加数据
List<String> list=new ArrayList<>();
Collections.addAll(list,"活该","和飞机喀什","暗示偶","合法i松开");
System.out.println(list);

//2.shuff():打乱List集合的中的元素顺序，set集合不用（本身就是无序的）
  Collections.shuffle(list);
System.out.println(list);

//3.sort():对List集合进行升序排序
List<Integer> list1=new ArrayList<>();
list1.add(23);
list1.add(2);
list1.add(222);
Collections.sort(list1);
System.out.println(list1);
//如果是对象的话，进行比较需要自己定义比较规则
List<Student>students=new ArrayList<>();
students.add(new Student("爱护就是",12,12));
students.add(new Student("爱护就是",111,12));
Collections.sort(students, (Student o1, Student o2) ->  Double.compare(o1.getHeight(),o2.getHeight()));

  //认识可便参数：定义在方法，构造器的形参列表中
    //格式：数据类型...参数名称
    //好处：可以灵活的接收数据
    //特点：
    test();//不传数据
    test(1);//传入一个数据
    test(10,12,122);//传入多个数据
    test(new int[]{1,2,3,4,5});//传入数组
}
//注意：1.一个形参列表中只能有一个可变参数
//     2，可变参数要放在形参列表的最后面
public static void test(int...numbers){
    //可变参数在方法的内部，本质就是一个数组
    System.out.println(numbers.length);
    System.out.println(Arrays.toString(numbers));
    System.out.println("------------------------");


}