集合

集合：

容器。

集合 和 数组区别：
1.数组 长度固定的；
集合 长度不固定；
2.数组 存储 基本 类型 和 引用类型；
集合 只能存储引用类型；
3.性能上。
数组更好；
集合底层数据结构复杂。

------------------------------------

接口：
Collection 接口
存储数据可以重复，无序
|
List接口 ：存储数据可以重复，有序。
|
实现类：
ArrayList
Vector -> Stack

LinkedList

-------------------------------------
区别：

底层数据结构 是数组：

ArrayList ：按照 50 %扩容
遍历 和 随机访问效率高。

Vector -> Stack栈
按照 100%扩容
性能低.
线程安全的。

底层数据结构 是链表。
LinkedList
插入 和 删除 效率高。

--------------------------------------

Set接口 ：集

数据唯一存储，无序

| — HashSet ->LinkedHashSet
SortedSet
|
NavigableSet
|
TreeSet

---------------------------------------

HashSet 类：
底层数据结构是 哈希表

Hash唯一存储原理：
首先 调用 hashCode()算出一个 哈希地址 ，
把 元素 存进去 ，如果 ，哈希 冲突的 ，
hashCode()的值 一样了 ，这时 才会调用‘
equals()判断 两个对象是否相同 ，相同不存储，
不同 可以存储。’

TreeSet:
底层数据结构 二叉树

树： 层次结构.

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
/**示例：Collection*/
public class TestCollection {

    public static void main(String[] args) {
        // 创建集合
        Collection<String> c = new ArrayList<>();
        //集合是否为空  元素个数为0就是空的  true 是空的
        System.out.println(c.isEmpty());
        //添加
        c.add("aa");
        c.add("bb");
        c.add("cc");
        System.out.println(c);
//        for(String s : c) {
//            System.out.println(s);
//        }
        //集合 是否为空
        System.out.println(c.isEmpty());//false
        //集合中元素的个数
        System.out.println(c.size());
        //新的集合 c1
        Collection<String> c1 = new ArrayList<>();
        c1.add("ee");
        c1.add("ff");
        System.out.println(c1);
        //把参数  集合 c1 中的 所有元素 添加到当前集合 c中 ,只要当前集合 发生了改变 true
        c.addAll(c1);
        System.out.println(c);
        //删除 指定 参数的 元素，只要当前集合 发生了改变true
        c.remove("aa");
        System.out.println(c);
        //删除 参数集合中的所有元素，只要 当前集合发生了改变 true
        c.removeAll(c1);
        System.out.println(c);
        //[bb, cc, eeee, fffffff]
        c.add("eeee");
        c.add("fffffff");
        System.out.println(c);
        //按照 条件 删除
    /*    c.removeIf(new Predicate<String>() {

            @Override
            public boolean test(String t) {
                return t.length()>2;
            }
        });*/
        c.removeIf(s->s.length()>2);
        System.out.println(c);
        //是否 存在参数 指定的元素，存在 true
        System.out.println(c.contains("cc"));//true
        //是否 存在 参数集合 中的全部 元素 ，全部都存在 是 true
        System.out.println(c.containsAll(c1));//false
        //把 数组 转换成集合   ArrayList是  Arrays的   静态内部类
        //不能添加 ，移除元素
        List<String> list = Arrays.asList(new String[] {"ee","ff"});
        System.out.println(list);
        c.addAll(list);
        System.out.println(c);
        System.out.println(c.containsAll(c1));
        
        //集合 转 数组
//        Object [] obj = c.toArray();
        Object [] obj = c.toArray(new Object[10]);
        for(Object o : obj) {
            System.out.println(o);
        }
        String [] strs = c.toArray(new String[4]);
        
        //清空集合中的所有元素
        c.clear();
        System.out.println(c.isEmpty());
        
    }

}

import java.util.ArrayList;
import java.util.List;
/**示例：List*/
public class TestList {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa"); // 0
        list.add("bb"); //1
        list.add("cc"); //2
        System.out.println(list);
        //向 参数 索引 位置添加一个元素
        list.add(1, "ff");
        System.out.println(list);
        //获得 参数 索引 处的元素
        System.out.println(list.get(0));//"aa"
        //用 第二个参数元素  替换 第一个参数索引处 的元素。
        list.set(1, "hello");
        System.out.println(list);
        list.add("aa");
        System.out.println(list);
        //查找 参数元素 在集合 中 第一次 出现的位置索引
        System.out.println(list.indexOf("aa"));//0
        //查找 参数元素 在集合 中最后一次 出现的位置索引
        System.out.println(list.lastIndexOf("aa"));//4
        //子集合 [起始位置,终止位置)
        System.out.println(list.subList(2, 4));//bb,cc
        //排序
        //按照 自然 升序 排序
        list.sort(null);
        System.out.println(list);
        //
        list.sort((o1,o2)->o2.compareTo(o1));
        System.out.println(list);            
    }

}

练习 

//16个队伍随机分成四组
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class JiheDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("科特迪瓦");
        list.add("阿根廷");
        list.add("澳大利亚");
        list.add("塞尔维亚");
        list.add("荷兰");
        list.add("尼日利亚");
        list.add("日本");
        list.add("美国");
        list.add("中国");
        list.add("新西兰");
        list.add("巴西");
        list.add("比利时");
        list.add("韩国");
        list.add("口客麦隆");
        list.add("洪都拉斯");
        list.add("意大利");
        Random r = new Random();
        for(int i=1;i<=4;i++) {
            System.out.println("第"+i+"组:");
            for(int n=0;n<4;n++) {
                String s = list.get(r.nextInt(list.size()));
                System.out.print(s+" ");
                list.remove(s);
            }
            System.out.println();
        }
    }
}

练习

package day14;

import java.util.ArrayList;
import java.util.List;

/**练习：List*/
class Student{
    private String name;
    private int age;
    private int score;
    private String classNum;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public String getClassNum() {
        return classNum;
    }
    public void setClassNum(String classNum) {
        this.classNum = classNum;
    }
    public Student(String name, int age, int score, String classNum) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
        this.classNum = classNum;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + ", classNum=" + classNum + "]";
    }
    
}
public class TestList2 {

    public void avgAge(List<Student> list) {
        int sum = 0;
        for(Student stu: list) {
            sum += stu.getAge();
        }
        System.out.println(sum / list.size());
    }
    public void avgScore(List<Student> list) {
        int sum1 ,sum2;
        sum1 = sum2 = 0;
        int n1 , n2 ;
        n1 = n2 = 0;
        for(Student stu: list) {
            if(stu.getClassNum().equals("Class01")) {
                sum1 += stu.getScore();
                n1 ++;
            }else if(stu.getClassNum().equals("Class02")){
                sum2 += stu.getScore();
                n2 ++;
            }
        }
        System.out.println("Class01:" + (sum1 / n1));
        System.out.println("Class02:" + (sum2 / n2));
    }
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三",22,90,"Class01");
        Student stu2 = new Student("李四",23,91,"Class01");
        Student stu3 = new Student("王五",24,92,"Class01");
        Student stu4 = new Student("赵六",25,93,"Class02");
        Student stu5 = new Student("周七",26,94,"Class02");
        Student stu6 = new Student("孙丽",27,95,"Class02");
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
        list.add(stu5);
        list.add(stu6);
        TestList2 t = new TestList2();
        t.avgAge(list);
        t.avgScore(list);
        
    }

}

练习

import java.util.ArrayList;
import java.util.List;
/**练习;List*/
class Dog implements Comparable<Dog>{
    private String name;
    private String type;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Dog(String name, String type, int age) {
        super();
        this.name = name;
        this.type = type;
        this.age = age;
    }
    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Dog [name=" + name + ", type=" + type + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Dog o) {
        return this.age - o.age ;
    }
    
}
public class TestListDog {

    public static void main(String[] args) {
        List<Dog> dogs = new ArrayList<Dog>();
        Dog wangwang = new Dog("旺旺","金毛",2);
        Dog meimei = new Dog("美美","吉娃娃",3);
        Dog wangcai = new Dog("旺财","松狮",1);
        dogs.add(wangwang);
        dogs.add(meimei);
        dogs.add(wangcai);
        //遍历
        dogs.forEach(System.out::println);
        //2.
        dogs.sort(null);
        //
        dogs.sort((dog1,dog2)->dog2.getAge() - dog1.getAge());
        //
        dogs.remove(meimei);
        //
        System.out.println(dogs.size());
    
    }

}

List集合遍历方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Consumer;

/**List集合遍历*/
public class TestListIterator {

    public static void main(String[] args) {
        //
        List<String> list = new ArrayList<>();
        list.add("aa");//0
        list.add("bb");//1
        list.add("cc");//2
        //1.基本for 只能 List-------------------------
        for(int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //2.增强for ---------------------------------
        for(String s : list) {
            System.out.println(s);
        }
        //3.集合的方法 (简单)
        list.forEach(new Consumer<String>() {
            //t 集合元素
            @Override
            public void accept(String t) {
                System.out.println(t);
            }
        });
        list.forEach(t->System.out.println(t));
        list.forEach(System.out::println);
        System.out.println("-----------------------");
        //Iterator
        //4.Iterator方法
        Iterator<String> i = list.iterator();
    /*    System.out.println(i.next());
        System.out.println(i.next());
        i.remove();//删除 最近一次 next()的元素
        System.out.println(list);*/
        while(i.hasNext()) {
            System.out.println(i.next());
        }
        //5.Iterator方法
        i.forEachRemaining(System.out::println);
        
        //6. ListIterator (针对 List)
        System.out.println("----------ListIterator-------------------");
        ListIterator<String> li = list.listIterator();
        while(li.hasNext()) {
            System.out.println(li.next());
            li.add("hello");
        }
        System.out.println("----------------------------");
        //向上
        while(li.hasPrevious()) {
            System.out.println(li.previous());
        }
        System.out.println("-----------------------");
        //7.
        list.stream().forEach(System.out::println);
        
    }

}

Set 重写hasCode() 和equals()自定义比较 集合元素是否存在

import java.util.HashSet;
import java.util.Set;

class Employee{
    private int no;
    private String name;
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Employee(int no, String name) {
        super();
        this.no = no;
        this.name = name;
    }
    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Employee [no=" + no + ", name=" + name + "]";
    }
    @Override
    public int hashCode() {
        // 哈希地址 
        return name.hashCode() + no;
    }
    @Override
    public boolean equals(Object obj) {
        // this ,obj
        // obj _ > Employee
        Employee e = (Employee)obj;
        return this.no == e.no && this.name.equals(e.name);
    }
    
}
public class TestSet1 {
    public static void main(String[] args) {
        Set<Employee> emps = new HashSet<>();
        Employee zhangsan = new Employee(2,"张三");
        Employee lisi = new Employee(1,"王五");
        Employee wangwu = new Employee(1,"王五");
        emps.add(zhangsan);
        emps.add(lisi);
        emps.add(wangwu);
        
        emps.forEach(System.out::println);
        
        
        
        //集合
/*        Set<String> set = new HashSet<>();
        set.add("aa");
        set.add("bb");
        set.add("cc");
        System.out.println(set);
        set.add("aa");
        System.out.println(set);*/
    }

}

 练习产生7个不相同 1-30的整数

import java.util.HashSet;
import java.util.Set;

/**练习：Set*/
public class TestSet2 {

    public static void main(String[] args) {
        // Set
        Set<Integer> set = new HashSet<>();
        int r;
        while(true) {
            r = (int)(Math.random()*(30-1+1)+1);
            set.add(r);// int ->Integer
            if(set.size() == 7) {
                break;
            }
        }
        set.forEach(System.out::println);
        
    }

}

SortedSet

import java.util.SortedSet;
import java.util.TreeSet;

public class TestSet3 {

    public static void main(String[] args) {
        // SortedSet
        SortedSet<Integer> set = new TreeSet<>((n1,n2)-> n2 - n1);
        set.add(111);
        set.add(33);
        set.add(55);
        System.out.println(set);
        set.forEach(System.out::println);
        System.out.println(set.first());
        System.out.println(set.last());
        //子集
        //  [起始元素 ，终止元素)
//        System.out.println(set.subSet(33, 111));
        
    }

}

NavigableSet

import java.util.NavigableSet;
import java.util.TreeSet;

public class TestSet4 {

    public static void main(String[] args) {
        // NavigableSet
        NavigableSet<Double> set = new TreeSet<>();
        set.add(11.1);
        set.add(55.5);
        set.add(22.2);
        set.add(99.9);
        System.out.println(set);
        //小于 等于 指定参数 的最大元素
        System.out.println(set.floor(20.0));
        //大于等于 指定参宿的 最小元素
        System.out.println(set.ceiling(20.0));
        //降序的集合
        System.out.println("-------------------------");
//        set.descendingSet().forEach(System.out::println);
        //降序的迭代器
        set.descendingIterator().forEachRemaining(System.out::println);
        //
        set.pollFirst();
        System.out.println(set);
        set.pollLast();
        System.out.println(set);
    }

}