09 Collection,Iterator,List,listIterator,Vector,ArrayList,LinkedList,泛型,增强for,可变参数，HashSet，LinkedHashSet，TreeSet

09 Collection,Iterator,List,listIterator,Vector,ArrayList,LinkedList,泛型,增强for,可变参数，HashSet，LinkedHashSet，TreeSet

import com.fly.bean.Student;

public class Demo1_Array {

    public static void main(String[] args) {
        Student[] arr = new Student[5]; //创建引用类型数组
        arr[0] = new Student("张三", 23);
        arr[1] = new Student("李四", 24);
        arr[2] = new Student("王五", 25);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            /*Student [name=张三, age=23]
            Student [name=李四, age=24]
            Student [name=王五, age=25]
            null
            null*/
        }

    }

}

集合框架：
集合的由来
    * 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给
我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
数组和集合的区别
    * 区别1 :
        * 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,

引用数据类型存储的是地址值
        * 集合只能存储引用数据类型(对象),集合中也可以存储基本数据类型,但是在存储的
时候会自动装箱变成对象
    * 区别2:
        * 数组长度是固定的,不能自动增长
        * 集合的长度的是可变的,可以根据元素的增加而增长
数组和集合什么时候用
        * 1,如果元素个数是固定的推荐用数组
        * 2,如果元素个数不是固定的推荐用集合

Collection(单列集合的根接口)->List有序，Set无序，不重复
List->ArrayList(数组实现)，LinkedList(链表实现)，Vector(数组实现)
Set->HashSet(哈希算法),TreeSet(二叉树算法)

Collection集合的基本功能：

import java.util.ArrayList;
import java.util.Collection;

import com.fly.bean.Student;

public class Demo2_Collection {

    @SuppressWarnings({ "rawtypes", "unchecked" }) //保持原始类型，不检查
    public static void main(String[] args) {
        Collection c = new ArrayList();
        boolean b = c.add("abc");
        boolean b1 = c.add(new Student("张三",12));
        System.out.println(b);//true  // List集合一直返回true，Set出现重复返回false
        System.out.println(b1);//true

        System.out.println(c);//[abc, Student [name=张三, age=12]]

        System.out.println(c.contains("abc"));//true  //是否包含
        c.remove("abc");
        System.out.println(c);//[Student [name=张三, age=12]]
        System.out.println(c.size());//1
        c.clear();   //清空
        System.out.println(c);//[]
        System.out.println(c.isEmpty());//true

    }

}

集合的遍历:

import java.util.ArrayList;
import java.util.Collection;

import com.fly.bean.Student;

public class Demo3_Collection {

    public static void main(String[] args) {
        // 集合的遍历
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

        Collection arr1 = new ArrayList();
        arr1.add(new Student("张三", 23));
        arr1.add(new Student("李四", 24));
        arr1.add(new Student("王五", 25));

        Object[] arr2 = arr1.toArray();
        for (int i = 0; i < arr2.length; i++) {
            Student student = (Student)arr2[i]; // 下转型
            System.out.println(student.getName()+" "+student.getAge());
        }
    }

}

Collection集合的带All功能：

boolean addAll(Collection c)
        boolean removeAll(Collection c)  删除的是交集，没有返回的是true
        boolean containsAll(Collection c)
        boolean retainAll(Collection c) 取交集，如果调用的集合不变就返回false

Iterator迭代器：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import com.fly.bean.Student;

public class Demo4_Iterator {

    public static void main(String[] args) {
        // 迭代
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        Iterator it = c.iterator(); //获取迭代器
        while(it.hasNext()) {
            System.out.println(it.next());
        }

        Collection arr1 = new ArrayList();
        arr1.add(new Student("张三", 23));
        arr1.add(new Student("李四", 24));
        arr1.add(new Student("王五", 25));
        Iterator it1 = arr1.iterator();
        while(it1.hasNext()) {
            Student student = (Student)it1.next();
            System.out.println(student.getName()+" "+student.getAge());
        }
    }

}

迭代器原理:

迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取
都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合
体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做
的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实
现,使用者不用管怎么实现的,会用即可

List：

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

public class Demo1_List {

    public static void main(String[] args) {
        // List
        List list = new ArrayList();
        list.add("a");
        list.add(1,"b"); //index [0~size]
//        list.add(5,"c");//IndexOutOfBoundsException

        System.out.println(list);//[a, b]
        Object object = list.remove(1);//按照索引删除，返回的是被删除的元素
        System.out.println(object);//b
        System.out.println(list);//[a]

        Object object2 = list.get(0);
        System.out.println(object2);//a
        Object object3 = list.set(0, "A");
        System.out.println(list);//[A]
    }

}

listIterator：

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

public class Demo2_List {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

/*        Iterator iterator = list.iterator();
        while(iterator.hasNext()) {
            String string = (String)iterator.next();
            if ("b".equals(string)) {
                list.add("B"); //遍历的同时再增加元素，并发修改

ConcurrentModificationException
            }
        }*/
        ListIterator listIterator = list.listIterator();////获取迭代器
        while(listIterator.hasNext()) {
            String string = (String)listIterator.next(); ////获取元素并将指针向

后移动
            if ("b".equals(string)) {
                listIterator.add("B");
            }
        }
        System.out.println(list);//[a, b, B, c, d]
        while(listIterator.hasPrevious()) {
            System.out.print(listIterator.previous());//dcBba ////获取元素并将

指针向前移动
        }

    }

}

Vector：

import java.util.Enumeration;
import java.util.Vector;

public class Demo3_Vector {

    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement("a");
        vector.addElement("b");
        vector.addElement("c");
        vector.addElement("d");

        Enumeration enumeration = vector.elements(); //获取枚举
        while(enumeration.hasMoreElements()) { //判断集合中是否有元素
            System.out.println(enumeration.nextElement());//获取集合中的元素
        }
    }

}

数组和链表：
* A:数组
    * 查询快修改也快  通过索引
    * 增删慢 后面所有的元素都要移动
* B:链表
    * 查询慢,修改也慢 从头找或从尾找
    * 增删快

List的三个子类的特点:
*
        ArrayList:
            底层数据结构是数组，查询快，增删慢。
            线程不安全，效率高。
        Vector:
            底层数据结构是数组，查询快，增删慢。
            线程安全，效率低。
        Vector相对ArrayList查询慢(线程安全的)
        Vector相对LinkedList增删慢(数组结构)
        LinkedList:
            底层数据结构是链表，查询慢，增删快。
            线程不安全，效率高。

Vector和ArrayList的区别
            Vector是线程安全的,效率低
            ArrayList是线程不安全的,效率高
        共同点:都是数组实现的
        ArrayList和LinkedList的区别
            ArrayList底层是数组结果,查询和修改快
            LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
        共同点:都是线程不安全的
List有三个子类，什么时候用？
        查询多用ArrayList
        增删多用LinkedList
        如果都多ArrayList

ArrayList：

import java.util.ArrayList;
import java.util.Iterator;

public class Demo1_ArrayList {

    public static void main(String[] args) {
        // ArrayList去除集合中字符串的重复值(字符串的内容相同)
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");

        ArrayList newList = getSingle(list);
        System.out.println(newList);//[a, b, c]

    }
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object object = it.next();
            if (!newList.contains(object)) {//contains，remove的底层都依赖

equals方法
                newList.add(object);
            }
        }
        return newList;
    }

}

LinkedList：

import java.util.LinkedList;

public class Demo2_LinkedList {

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");
        list.addFirst("d");

        /*System.out.println(list); // [d, c, b, a]
        System.out.println(list.getFirst()); //d
        System.out.println(list.getLast());  //a
        System.out.println(list.removeFirst());//d
        System.out.println(list.removeLast());//a
        System.out.println(list);//[c, b]
*/
        System.out.println(list.get(0)); //d
        }

}

LinkedList模拟栈结构：

import java.util.LinkedList;

public class Stack {
    /*LinkedList模拟栈结构*/
    private LinkedList list = new LinkedList();

//    进栈
    public void push(Object object) {
        list.addLast(object);
    }

//    出栈
    public Object pop() {
        return list.removeLast();
    }

//    判断是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

泛型：

import java.util.ArrayList;
import java.util.Iterator;

import com.fly.bean.Person;

public class Demo1_Generic {

    public static void main(String[] args) {
    /*    泛型好处
            * 提高安全性(将运行期的错误转换到编译期)
            * 省去强转的麻烦
        泛型基本使用
            * <>中放的必须是引用数据类型
        泛型使用注意事项
            * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型

) */
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",19));
        list.add(new Person("李四",18));

        Iterator<Person> iterator = list.iterator();
        while(iterator.hasNext()) {
            Person person = iterator.next();
            System.out.println(person); // Person [name=张三, age=19] Person

[name=李四, age=18]
        }

    }

}

泛型的由来:

通过Object转型问题引入

/*把泛型定义在类上
定义格式
public class 类名<泛型类型1,…>*/
public class Tool<E> {
    private E e;

    public E getObj() {
        return e;
    }

    public void setObj(E e) {
        this.e = e;
    }

/*把泛型定义在方法上
定义格式
    public <泛型类型> 返回类型 方法名(泛型类型 变量名)*/
    public<T> void show(T t) {
        System.out.println(t);
    }

}

增强for：

import java.util.ArrayList;

public class Demo1_Foreach {

    public static void main(String[] args) {
    /*    增强for概述
             简化数组和Collection集合的遍历
         格式：
            for(元素数据类型 变量 : 数组或者Collection集合) {
                使用变量即可，该变量就是元素
            }
        底层依赖的是迭代器
*/
        //遍历数组
        int[] arr = {11,22,33,44,55};
        for(int i:arr) {
            System.out.println(i);
        }
        //遍历集合
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        for(String string:list) {
            System.out.println(string);
        }
    }

}

迭代的删除：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo2_Del {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("c");
        list.add("d");
        list.add("a");
        list.add("a");
/*        // 普通for循环,索引--
        for (int i = 0; i < list.size(); i++) {
            if ("a".equals(list.get(i))) {
                list.remove(i--);
            }
        }*/

        //迭代器while方式
/*        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if ("a".equals(iterator.next())) {
//                list.remove("a");//并发修改异常
                iterator.remove();
            }

        }*/

    /*    //迭代器for方式
        for(Iterator<String> iterator=list.iterator();iterator.hasNext();) {
            if ("a".equals(iterator.next())) {
                iterator.remove();
            }
        }
        System.out.println(list);//[c, d]
*/
        //补充：
/*        ListIterator<String> iterator = list.listIterator();
        while (iterator.hasNext()) {
            if ("a".equals(iterator.next())) {
                iterator.remove();
                iterator.add("A");//ListIterator有add,Iterator没有
            }

        }
        System.out.println(list);//[A, A, c, d, A, A]
*/
        //增强for不能删除，只能遍历
    }

}

可变参数...

public class Demo3_ChangeableArgs {
/*    可变参数
    格式:
        修饰符 返回值类型 方法名(数据类型…  变量名){}
    这里的变量其实是一个数组
    如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个*/
    public static void main(String[] args) {
        print("a",11,22,33,44);
    }

    public static void print(String s,int...arr) {
        System.out.println(s);
        for (int i : arr) {
            System.out.println(i);
        }
    }

}

数组--集合:

import java.util.Arrays;
import java.util.List;

public class Demo4_AsList {

    public static void main(String[] args) {
        //Arrays工具类的asList()方法的使用
        // 数组转集合,不能添加，但可以用其它集合中的方法
        //数组必须是引用数据类型
        String[] arr = {"11","22","33"};
        List<String> list = Arrays.asList(arr);
//        list.add("a"); //UnsupportedOperationException 不能添加
        System.out.println(list);//[11, 22, 33]

        int[] arr2 = {11,22,33,44};
        List<int[]> list2 = Arrays.asList(arr2);
        System.out.println(list2);//[[I@15db9742]

        Integer[] arr3 = {11,22,33,44};
        List<Integer> list3 = Arrays.asList(arr3);
        System.out.println(list3);//[11, 22, 33, 44]

                //集合转数组
        ArrayList<String> list4 = new ArrayList<>();
        list4.add("a");
        list4.add("b");
        list4.add("c");
        list4.add("d");

        String[] arr4 = list4.toArray(new String[5]);//指定数组的长度，小于size就会

等于
        for (String string : arr4) {
            System.out.print(string+" ");//a b c d null
        }

    }

}

import java.util.ArrayList;

import com.fly.bean.Person;

public class Demo3_ArrayList {

    public static void main(String[] args) {
        // 集合嵌套集合
        ArrayList<ArrayList<Person>> list = new ArrayList<>();
        ArrayList<Person> arrayList = new ArrayList<>();
        arrayList.add(new Person("a",1));
        arrayList.add(new Person("b",2));
        arrayList.add(new Person("c",3));

        ArrayList<Person> arrayList2 = new ArrayList<>();
        arrayList2.add(new Person("A",11));
        arrayList2.add(new Person("B",22));
        arrayList2.add(new Person("C",33));

        list.add(arrayList);
        list.add(arrayList2);
        for (ArrayList<Person> list2 : list) {
            for (Person person : list2) {
                System.out.println(person);
            /*    Person [name=a, age=1]
                Person [name=b, age=2]
                Person [name=c, age=3]
                Person [name=A, age=11]
                Person [name=B, age=22]
                Person [name=C, age=33]*/
            }
        }
    }
}

HashSet:

import java.util.HashSet;

import com.fly.bean.Person;

public class Demo1_Set {

    public static void main(String[] args) {
        HashSet<String> hSet = new HashSet<>(); //Set集合，无索引，不可重复，无序
        boolean b1 = hSet.add("a");
        boolean b2 = hSet.add("a");

        System.out.println(hSet);//[a] 当向set集合中存储重复元素的时候返回为false
        System.out.println(b1);//true
        System.out.println(b2);//false

        HashSet<Person> hPersons = new HashSet<>();
        hPersons.add(new Person("小明",19));
        hPersons.add(new Person("小明",19));
        hPersons.add(new Person("李四",19));
        hPersons.add(new Person("李四",19));
        hPersons.add(new Person("李四",17));
        hPersons.add(new Person("张三",17));

        System.out.println(hPersons.size());//
        System.out.println(hPersons);//[Person [name=小明, age=19], Person [name=李

四, age=19], Person [name=李四, age=17], Person [name=张三, age=17]]

    }

}

Person类：

public class Person {
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        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;
    }
    //将自定义类的对象存入HadhSet去重，必须重写hashCode()和equals()方法
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() { //只有在hashcode相同时才会执行equals
        final int prime = 31;//31是一个质数，这个数不大不小，是2的5次方-1，即2向左

移动5位减一
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) //调用的对象和传入的对象是同一个对象
            return true;
        if (obj == null) //传入的对象是null
            return false;
        if (getClass() != obj.getClass()) //判断两个对象对应的字节码文件是否是同一

个字节码
            return false;
        Person other = (Person) obj; //向下转型
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

LinkedHashSet：

import java.util.LinkedHashSet;

public class Demo2_LinkedHashSet {

    public static void main(String[] args) {
        // LinkedHashSet
        //底层是链表实现的
        //元素唯一
        LinkedHashSet<String> linkedHashSet= new LinkedHashSet<>();
        linkedHashSet.add("a");
        linkedHashSet.add("a");
        linkedHashSet.add("b");
        linkedHashSet.add("c");

        System.out.println(linkedHashSet);//[a, b, c]
    }

}

import java.util.HashSet;
import java.util.Random;

public class Test1 {

    public static void main(String[] args) {
        // 10个1~20的随机数，不重复
        Random random = new Random();
        HashSet<Integer> hs = new HashSet<>();
        while(hs.size()<10) {
            hs.add(random.nextInt(20)+1);
        }
        for (Integer integer : hs) {
            System.out.println(integer);
        }
    }

}

TreeSet：

import java.util.TreeSet;

import com.fly.bean.Person;

public class Demo3_TreeSet {

    public static void main(String[] args) {
        //TreeSet集合可以对对象集合排序，同时保证元素唯一
        //底层是二叉树
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(3);
        ts.add(4);
        ts.add(1);
        ts.add(2);
        ts.add(2);
        ts.add(2);

        System.out.println(ts);//[1, 2, 3, 4]

        TreeSet<Person> ts2 = new TreeSet<>();
        ts2.add(new Person("张三",18));
        ts2.add(new Person("李四",19));
        ts2.add(new Person("王五",20));
        ts2.add(new Person("赵六",21));

        System.out.println(ts2);

    /*    public class Person implements Comparable<Person>{

            .....

            //重写compareTo，返回值决定存储方式
            @Override
            public int compareTo(Person o) {
                return -1; // 负数时返回集合，倒序
                          // 0 返回集合只有一个元素，正数存储顺序
                //按照年龄排
//                int num = this.age - o.age;
//                return num == 0?this.name.compareTo(o.name):num;

            }
        }*/

    }

}

比较器：

import java.util.Comparator;
import java.util.TreeSet;

public class Demo4_TreeSet {

    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>(new CompareByLen());
        treeSet.add("ab");
        treeSet.add("1234");
        treeSet.add("fly");
        treeSet.add("qwer");

        System.out.println(treeSet);//[ab, fly, 1234, qwer]
    }

}
class CompareByLen implements Comparator<String>{
    //比较器
    @Override
    public int compare(String o1, String o2) {
        // 按照字符串的长度比较
        //o2是已有的，o1是新来的
        int num = o1.length()-o2.length();
        return num==0 ? o1.compareTo(o2) : num;
    }

}

练习：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import javax.naming.ldap.SortControl;

public class Test2 {

    public static void main(String[] args) {
        //在一个集合中存储了无序并且重复的字符串,
        //定义一个方法,让其有序(字典顺序),而且还不能去除重复
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("absf");
        list.add("ccc");
        list.add("aaa");
        sort(list);
        System.out.println(list);//[aaa, aaa, absf, ccc]
    }

    public static void sort(List<String> list) {
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                int num = o1.compareTo(o2);
                return num==0 ? 1 : num;
            }
        });
        treeSet.addAll(list);
        list.clear();
        list.addAll(treeSet);
    }
}

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test3 {

    public static void main(String[] args) {
        //从键盘接收一个字符串, 程序对其中所有字符进行排序
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String line = scanner.nextLine();

        char[] arr = line.toCharArray();//将字符串转换为字符数组
        TreeSet<Character> treeSet = new TreeSet<>(new Comparator<Character>() {

            @Override
            public int compare(Character o1, Character o2) {
                int num = o2 - o1;
                return num==0 ? 1 : num;
            }
        });
        //遍历字符数组，将每一个字符储存在TreeSet集合中
        for (Character character : arr) {
            treeSet.add(character);
        }
        //遍历TreeSet集合
        for (Character character : treeSet) {
            System.out.println(character);
        }
    }

}