16-java学习-ArrayList、Vector、LinkedList、泛型(Generic)、可变参数、增强for循环-案例代码

16-java学习-ArrayList、Vector、LinkedList、泛型(Generic)、可变参数、增强for循环-案例代码

1.ArrayList存储字符串并遍历泛型版

public class MyTest {
    public static void main(String[] args) {
        //泛型机制：就是把类型明确工作，推迟到创建对象，或调用方法是，才去明确的一种机制。
        //泛型的好处：1.将问题提前到了编译期，2.避免了向下转型。
        //泛型需要注意的是，泛型只在编译期有效，运行期就擦除了
        //泛型可以定义在类，接口，方法上 语法<类型>
        ArrayList<Integer> list = new ArrayList();
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);

        ArrayList list2 = new ArrayList();
        list2.add("abc");

        Object o = list2.get(0);
        String str= (String) o;
        System.out.println(str.length());
    }
}

2. ArrayList存储自定义对象并遍历泛型版

public class MyTest2 {
    public static void main(String[] args) {
        //JDK1.5 之后引入泛型的
        ArrayList<String> list = new ArrayList<String>();
        list.add("aaaa");
        list.add("aaaa");
        list.add("aaaa");
        list.add("aaaa");
        list.add("aaaa");

        //String s = list.get(0);
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

        System.out.println("=======================");
        ArrayList<Object> list2 = new ArrayList<>();
    }
}

3.

public class LinkedListDemo {
    public static void main(String[] args) {
      /*  void addFirst (E e)
        在此列表的开始处插入指定的元素。
        void addLast (E e)
        将指定的元素列表的结束。

        E getFirst ()
        返回此列表中的第一个元素。
        E getLast ()
        返回此列表中的最后一个元素。

        E peek ()
        检索，但不删除，此列表的头（第一个元素）。

        E poll ()
        检索并删除此列表的头（第一个元素）。

        E pop ()
        从这个列表所表示的堆栈中弹出一个元素。

        E removeFirst ()
        移除并返回此列表中的第一个元素。

        E removeLast ()
        移除并返回此列表中的最后一个元素。

*/

        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(100);
        linkedList.addFirst(200);
        linkedList.addFirst(300);

        Object pop = linkedList.pop();
        System.out.println(pop);

        Object pop2 = linkedList.pop();
        System.out.println(pop2);

        System.out.println(linkedList);
    }
}

4.void forEach (Consumer < ? super E > action)

    执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。

public class MyTest {
    public static void main(String[] args) {
        //List 集合元素有序，且允许重复元素
       // ArrayList 底层数据结构是数组，查询快，增删慢 线程不安全效率高
       // LinkedList 底层数据结构是链表，查询慢，增删快 线程不安全效率高
        //Vector  底层数据结构是数组，查询快，增删慢  线程安全 效率低
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("dddd");
        list.add("eee");
        list.add("fff");
        //Consumer 接口
        //当你以后看到一个方法的形参，要一个接口类型，你就传一个该接口的子类对象
        //方式1，你定义一个类，实现这个接口
        //方式2：匿名内部类
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}
class MyConsumer implements Consumer<String>{
    @Override
    public void accept(String s) {
        //s 就是你集合中的元素
        System.out.println(s);
    }
}

5.Vector

 /* void addElement (E obj)
        添加指定的组件到这个向量的结束，增加其大小由一个。

        E elementAt ( int index)
        返回指定索引处的组件。

        E firstElement ()
        返回第一个组件（在指数 0 项目）这个载体。

        E lastElement ()
        返回向量的最后一个组件。


        void removeAllElements ()
        从该向量中移除所有组件，并将其大小设置为零。
        boolean removeElement (Object obj)
        从该向量中移除第一个（最低索引）发生的参数。

        void removeElementAt ( int index)
        在指定的索引中删除组件。

        void setElementAt (E obj,int index)
        设置组件在指定的 index这个向量是指定的对象。*/

public class VectorDemo {
    public static void main(String[] args) {
      

        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        vector.addElement(400);

        //Vector 集合有一个自己的迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }

        System.out.println("============================");

        Object o = vector.elementAt(0);
        Object o1 = vector.firstElement();
        Object o2 = vector.lastElement();

        vector.removeElement(100);
        vector.removeAllElements();
    }
}

6. 初始化LinkedList

public class MyList {
    private LinkedList linkedList=null;
    public MyList() {
      
       linkedList = new LinkedList();
    }

    public void add(Object obj) {
        linkedList.addFirst(obj);

    }

    public Object get() {
        Object poll = linkedList.poll();
        linkedList.addLast(poll);
        return poll;
    }
}

7.需求：请用LinkedList模拟栈数据结构的集合，并测试

public class MyTest {
    public static void main(String[] args) {
     
       //栈的数据结构；先进后出，后进先出
        
        MyList myList = new MyList();
        myList.add(100);
        myList.add(200);
        myList.add(300);
        myList.add(400);
        myList.add(500);
        myList.add(600);

       Object obj= myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);

        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
    }
}

8.需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

public class MyTest2 {
    public static void main(String[] args) {
       
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("ccc");
        list.add("ccc");
        //可以利用创建新集合的方式来去去除集合中的重复元素
        ArrayList newList = new ArrayList();

        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if(!newList.contains(o)){
                newList.add(o);
            }
        }

        System.out.println(newList);
    }
}

9. ArrayList 遍历

public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("张三", 23);
        Student s3 = new Student("李四", 24);
        Student s4 = new Student("李四", 24);
        Student s5 = new Student("王五", 25);
        Student s6 = new Student("王五", 25);
        ArrayList list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        list.add(s6);

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Student student= (Student) list.get(i);
            if(!newList.contains(student)){
                newList.add(student);
            }
        }

        System.out.println("====================");
        for (int i = 0; i < newList.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

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

10. 泛型机制：就是把类型明确工作，推迟到创建对象或调用方法时，再去明确的工作

    泛型可以提高代码的扩展性和灵活性
    可以把问题提前到编译器，可以避免向下转型。
    泛型只在编译期有效，到运行期就擦除了。
    泛型可以使用在 类 接口 方法上

public class MyTest {
    public static void main(String[] args) {
  

        int[] arr={10,20,30,40,50};
      
       for(int ele:arr){
           System.out.println(ele);
       }
        System.out.println("==============================");
        ArrayList<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);

        for(Integer ele:list){
            System.out.println(ele);
        }
        for (int i : arr) {

        }

        System.out.println("========================");
        for (int i = 0; i < list.size(); i++) {

        }

        for (Integer integer : list) {

        }

    }
}

11.ConcurrentModificationException

注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

public class MyTest2 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(200);
        list.add(50);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);


   
        for (Integer integer : list) {

        }

        for (int i = 0; i < list.size(); i++) {
                if(i==2){

                }
        }
    }
}

12.把一个集合转成数组、把一个数组转换成集合

public class MyTest2 {
    public static void main(String[] args) {
        //把一个集合转成数组
        ArrayList<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        Object[] objects = list.toArray();
        System.out.println("=================================");
        //把一个数组转换成集合
        Integer[] integers = {20, 30, 50};
        //当你传进来的是一个数组，他会把数组中的元素 取出来放到集合中
        List<Integer> integers1 = Arrays.asList(integers);
        for (Integer integer : integers1) {
            System.out.println(integer);
        }

        System.out.println("===========================");
        Integer[] integers2 = {20, 30, 50};
        Integer[] integers3 = {20, 30, 500};
        //当你传进来的是两个以上的数组，那么他是把数组放到集合中
        List<Integer[]> list1 = Arrays.asList(integers2, integers3);
        for (Integer[] integers4 : list1) {
            System.out.println(integers4);
            for (Integer integer : integers4) {
                System.out.println(integer);
            }
        }

       /* Integer integer = list1.get(1)[2];
        System.out.println(integer);*/


        System.out.println("===============================");



        Integer[] integers4 = {200, 300, 500};


        int[] arr={1,2,3};

        //当你传进来一个元素是引用类型的数组，那么他会把数组中的元素取出来放到集合中

        List<Integer> integers5 = Arrays.asList(integers4);
        Integer integer = integers5.get(2);
        System.out.println(integer);

        //当你传进来是一个基本类型的数组，他是把这个数组放到集合中
        List<int[]> ints = Arrays.asList(arr);
        int i = ints.get(0)[2];
        System.out.println(i);

        System.out.println("=========================================");

        Integer[] integers6 = {20, 30, 50,60,70};
        //通过asList(integers6);转换过来的这个集合，这个集合不能增删元素
        List<Integer> list2 = Arrays.asList(integers6);
        Integer integer1 = list2.get(0);
        System.out.println(integer1);
        list2.set(1,300);

        System.out.println(list2);

        //list2.add(600);
        list2.remove(0);
        list2.remove(new Integer(20));


        //把这些元素放到集合中
        List<Integer> integers7 = Arrays.asList(20, 30, 20, 30, 50);

    }
}

13.ArrayList嵌套ArrayList

public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("张三1", 23);
        Student s2 = new Student("张三2", 23);
        Student s3 = new Student("张三3", 23);
        Student s4 = new Student("张三4", 23);
        Student s5 = new Student("张三5", 23);
        Student s6 = new Student("张三6", 23);
        Student s7 = new Student("张三7", 23);


        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(s1);
        javaList.add(s2);
        javaList.add(s3);


        ArrayList<Student> phpList = new ArrayList<>();
        phpList.add(s4);
        phpList.add(s5);


        ArrayList<Student> webList = new ArrayList<>();
        javaList.add(s6);
        javaList.add(s7);

        //这是一个最大的集合，存储三个小集合
        //二维集合
        ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
        maxList.add(javaList);
        maxList.add(phpList);
        maxList.add(webList);

        //遍历最大的集合，打印出每个学生的信息

        //普通for循环遍历
        for (int i = 0; i < maxList.size(); i++) {
            ArrayList<Student> students = maxList.get(i);
            for (int j = 0; j < students.size(); j++) {
                Student student = students.get(j);
                System.out.println(student.getName()+"=="+student.getAge());
            }
        }

        System.out.println("==================================");
        for (ArrayList<Student> students : maxList) {
            for (Student student : students) {
                System.out.println(student.getName() + "==" + student.getAge());
            }
        }

    }
}

public class Student {
    private String name;
    private int age;

    public Student(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;
    }
}