java集合

集合概念

• 集合：对象的容器，并且提供操作的方法（≈数组）。import java.util.*
• 集合vs数组
  • 长度：集合不固定，数组固定
  • 数组：8基本，引用类型。集合：引用类型。

Collection接口

• List接口：有序
  • ArrayList，LinkedList，Vector(安全)
• Set接口：无序，不可重复
  • HashSet，TreeSet(实现接口SortedSet)，
• Collection → ArrayList();

Collection collection = new ArrayList();//可重复，无下标
collection.add("苹果");
collection.add("香蕉");
collection.add("西瓜");
System.out.println(collection);
collection.size();
collection.remove("香蕉");

//collection.clear();
//collection.contains("西瓜")
//collection.isEmpty()
//遍历：增加for。迭代器

• 存储对象。无序

Collection collection = new ArrayList();//可重复，无下标
Student adair = new Student("adair", 18);
Student tom = new Student("tom", 19);
Student jerry = new Student("jerry", 20);

collection.add(adair);
collection.add(tom);
collection.add(jerry);
collection.remove(adair);   //只是去掉引用，对象本身还是存在的
collection.remove(new Student("jerry", 20));//必须重写Student的equal。字符串、数字不需要重写

System.out.println(collection);
//[Student{name='tom', age=19}, Student{name='jerry', age=20}]
//		sout('\'')

List接口

• List → ArrayList();

List list = new ArrayList();//有下标

list.add("adair");
list.add("tom");
list.add(0,"jerry");
list.remove("jerry");	//字符串相同，是同一个对象
list.remove(0);

//遍历：增强for,list.iterator()


ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()){
    System.out.println(listIterator.nextIndex() + "  " + listIterator.next());
}
//list.indexOf("tom");

• List → ArrayList();

List list = new ArrayList();
//自动装箱
list.add(10);
list.add(2000);
list.add(30);
list.add("123");

list.remove(new Integer(2000));//正确。arraylist.remove()中有equal()
list.remove(new String("123"));//正确。

list.subList(0,1);

• object的比较

Integer integer1 = new Integer(20);
Integer integer2 = new Integer(20);
System.out.println(integer1.equals(integer2));  //true
System.out.println(integer1 == integer2);     //false

• ArrayList(数组。不安全)，Vector(数组。安全)，LinkedList(链表)
• 查看ArrayList和.add()源码
• ArrayList → ArrayList<>();

        ArrayList arrayList = new ArrayList<>();
        Student adair = new Student("adair", 17);
        Student tom = new Student("tom", 18);
        Student jerry = new Student("jerry", 19);

        arrayList.add(adair);
        arrayList.add(tom);
        arrayList.add(jerry);

//        Class Student下的
//        @Override
//        public boolean equals(Object obj) {	//核心
//            if(obj instanceof Student){
//                Student obj1 = (Student) obj;
//                if(this.getName().equals(obj1.name)&&this.getAge() == obj1.getAge()){
//                    return true;
//                }
//            }
//            return false;
//        }

        //重写Student的equal方法。remove中调用了equal
        arrayList.remove(new Student("adair", 17));

        arrayList.listIterator();
        
        arrayList.contains(new Student("tom", 18));//也是利用student重写equal

• Vector vector = new Vector()

Vector vector = new Vector();

vector.add("aaa");
vector.add("bbb");
vector.add("ccc");

Enumeration elements = vector.elements();	//≈arraylist的迭代器
while (elements.hasMoreElements()){
    Object o = elements.nextElement();
    System.out.println(o);
}

• LinkedList → LinkedList<>();

LinkedList<Object> objects = new LinkedList<>();
Student adair = new Student("adair", 17);
Student tom = new Student("tom", 18);
Student jerry = new Student("jerry", 19);
objects.add(adair);
objects.add(tom);
objects.add(jerry);
objects.add(jerry);

Set接口

• Set → HashSet<>();

public class Test{
    public static void main(String[] args) {
        Set<Object> objects = new HashSet<>();	//无重复，无下标
        objects.add("adair");
        objects.add("tom");
        objects.add("jerry");
        objects.add("jerry");

        System.out.println(objects);

        Iterator<Object> iterator = objects.iterator();
        objects.contains("adair");
    }
}

• HashSet → HashSet<>();

public class Test{
    public static void main(String[] args) {
        HashSet<String> objects = new HashSet<>();
        objects.add("adair");
        objects.add("tom");
        objects.add("jerry");
        objects.add("jerry");
        objects.remove("jerry");

        objects.contains("adair");
        Iterator<String> iterator = objects.iterator();
    }
}

• HashSet → HashSet<>();

public class Test{
    public static void main(String[] args) {
        //存储的结构：eg买火车票
        HashSet<Person> peoples = new HashSet<>();
        Person adair = new Person("adair", 17);
        Person tom = new Person("tom", 17);
        Person jerry = new Person("jerry", 17);

        peoples.add(adair);
        peoples.add(tom);
        peoples.add(jerry);
        peoples.add(new Person("adair", 17));//可以添加，因为：地址不同(虽然内容相同)
        //重写hashCode()计算在hashset的位置，
        //重写equals()，在位置上的链表是否有重复元素
        //这样就不重复了

        peoples.remove(new Person("adair", 17));//重写两个方法之后，才可以删除

        Iterator<Person> iterator = peoples.iterator();
    }
}
================================================================
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//    @Override
//    public int hashCode() {	//自己写的
//        int n1 = this.name.hashCode();
//        int n2 = this.age;
//        return n1+n2;
//    }
//
//    @Override
//    public boolean equals(Object obj) {
//        if (obj instanceof Person){
//            Person person = (Person) obj;
//            if (this.name.equals(person.getName())&&this.age==person.getAge())    return true;
//        }
//        return false;
//    }


    @Override
    public boolean equals(Object o) {//快速生成的
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

    @Override
    public int hashCode() {	//内部+31(质数),减少冲突，更高的效率
        return Objects.hash(name, age);
    }
}

• TreeSet → TreeSet<>();若字符串，自动排列

public class Test{
	//使用红黑树
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("aaa");         //会自动排序
        treeSet.add("ccc");
        treeSet.add("bbb");
        treeSet.remove("aaa");

        Iterator<String> iterator = treeSet.iterator();
        treeSet.contains("aaa");
    }
}

• TreeSet → TreeSet<>();若对象，先比较comparator(comparator会自动实现，有方法调用它)

public class Test{
    //存储结构：红黑树
    //要求：在Person中实现Comparable接口
    public static void main(String[] args) {
        TreeSet<Person> peoples = new TreeSet<>();
        Person adair = new Person("adair", 17);
        Person tom = new Person("tom", 17);
        Person jerry = new Person("jerry", 17);

        peoples.add(adair);
        peoples.add(tom);
        peoples.add(jerry);
        peoples.add(new Person("jerry", 17));//相同，不可添加
        peoples.remove(new Person("jerry", 17));

        Iterator<Person> iterator = peoples.iterator();
    }
}
================================================================
public class Person implements Comparable<Person>{//treeset存储对象，必须要先比较
    @Override
    public int compareTo(Person o) {//先比name，再比age
        int n1 = this.name.compareTo(o.name);
        int n2 = this.getAge() - o.age;
        return n1==0?n2:n1;	//返回0，则说明是相同元素，不可添加
    }

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

• 匿名内部类new Comparator<Person>() { }

TreeSet<Person> peoples = new TreeSet<>(new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        int n1 = o1.getName().compareTo( o2.getName());
        int n2 = o1.getAge() - o2.getAge();
        return n1==0?n2:n1;
    }
});

• 指定接口Comparator规则

public class Test{
    public static void main(String[] args) {
        //创建集合，并指定规则，规则会自动实现
        //先按照string长度,(length相同则正常比)
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length() - o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        treeSet.add("zz");
        treeSet.add("abc");
        treeSet.add("abcd");
        treeSet.add("xxxxx");
        treeSet.add("xxx");
        System.out.println(treeSet);
    }
}

Map接口

• Map接口
  • HashMap
  • TreeMap(实现接口SortedMap)
• hashset调用hashmap(只存储map的key)。treeset调用treemap
• Map<String, String> map = new HashMap<String, String>();

public class Test{
    //存储键值对(无序)。键不能重复。
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("us","美国");
        map.put("us","漂亮国");//覆盖掉

        map.keySet();//得到所有key
        map.values();//得到所有value

        for (String key : map.keySet()) {//keySet键集合
            System.out.println(map.get(key));
        }
        for (Map.Entry<String, String> entry : map.entrySet()) {//entrySet键值对集合
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
        map.containsKey("cn");
        map.containsValue("中国");
    }
}

• HashMap<Student, String> → HashMap<>();

public class Test{
    //存储结构：哈希表(数组+链表+红黑树)
    public static void main(String[] args) {
    	//hashmap创建时，table=null,size=0。≈arrayList
        HashMap<Student, String> map = new HashMap<>();
        Student s1 = new Student("adair", 17);
        Student s2 = new Student("tom", 17);
        Student s3 = new Student("jerry", 17);
        map.put(s1,"北京");
        map.put(s2,"上海");
        map.put(s3,"广州");
        //可以加入，内容一样，但是地址不一样
        //重写hashcode和equal
        map.put(new Student("adair", 17),"nihao");

        map.remove(s1);

        //增强for遍历：使用keyset()。使用entryset()。
    }
}

• hashmap的源码分析：数组长度>64，链表>8→红黑树

• TreeMap<Student, String> map = new TreeMap<>()

public class Test{
    //存储结构：哈希表(数组+链表+红黑树)
    public static void main(String[] args) {
        TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {
            @Override   //比较map中的key(student)值
            public int compare(Student o1, Student o2) {
                int n1 = o1.getName().compareTo(o2.getName());
                int n2 = o1.getAge() - o2.getAge();
                return n1==0?n2:n1;
            }
        });
        Student s1 = new Student("adair", 17);
        Student s2 = new Student("tom", 17);
        Student s3 = new Student("jerry", 17);
        map.put(s1,"北京");
        map.put(s2,"上海");
        map.put(s3,"广州");
        //可以加入，内容一样，但是地址不一样
        //重写hashcode和equal
        System.out.println(map);

        map.remove(s1);

        //增强for遍历：使用keyset()。使用entryset()。
    }
}

Generic

• 泛型类，泛型接口，泛型方法。优点：提高代码的重用性
• MyGeneric<String> → MyGeneric<>()。调用泛型方法的时候，会根据参数自动确定类型

public class Test{
    public static void main(String[] args) {  
        MyGeneric<String> stringMyGeneric = new MyGeneric<>();
        stringMyGeneric.t = "hello";
        stringMyGeneric.show("world");
        System.out.println(stringMyGeneric.getT());
        //不同泛型对象不可相互赋值，string和int不同
        
        MyMethod myMethod = new MyMethod();
        myMethod.show("string");    //不需要传递类型，传递的数据自然决定了传递的类型
        myMethod.show(1.23);
    }
}

class MyGeneric<T>{		//泛型类
    T t;				//不可new
    public void show(T t){
        System.out.println(t);
    }
    public T getT(){
        return t;
    }
}

class MyMethod{		//泛型方法。由传递的参数决定类型
    public <T> T show(T t){ //泛型<T>,返回值T
        return t;
    }
}

• 泛型接口，泛型类，泛型方法

public class Test{
    public static void main(String[] args) {
        MyImplement myImplement = new MyImplement();
        myImplement.server("xiaoming");

        MYImplement2<Integer> integerMYImplement2 = new MYImplement2<>();
        System.out.println(integerMYImplement2.server(10));
    }
}


class MYImplement2<T> implements MyInterface<T>{//泛型类，未知类型
    @Override
    public T server(T t) {
        return t;
    }
}

class MyImplement implements MyInterface<String>{//泛型类，已知类型
    @Override
    public String server(String s) {
        return s;
    }
}

interface MyInterface<T>{//泛型接口
    T server(T t);
}

• 泛型集合

        ArrayList<String> strings = new ArrayList<>();//只能添加string的arraylist。泛型不存在多态
        strings.add("adair");
//        strings.add(1213);报错。已经固定了类型
        Iterator<String> iterator = strings.iterator();

Collection工具类

• shuffle

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        ArrayList<Integer> dest = new ArrayList<>();
        arrayList.add(11);
        arrayList.add(1);
        arrayList.add(21);
        arrayList.add(111);

		//排序
        Collections.sort(arrayList);

        Collections.binarySearch(arrayList, 21);//返回index

		//复制
        for (int i = 0; i < arrayList.size(); i++) {
            dest.add(0);
        }
        Collections.copy(dest,arrayList);

        Collections.reverse(arrayList);

        Collections.shuffle(arrayList);

        //arraylist → 数组
        Object[] nums = arrayList.toArray();
        
        //数组 → arraylist。受限list(不可增删)
        List<Object> list = Arrays.asList(nums);

        //必须以箱装进。不可是int
        Integer[] nums2 = {12,11,10,13};
        List<Integer> integers = Arrays.asList(nums2);
    }
}