Java集合2_ArrayList

1  集合2

1.1 去除ArrayList中重复字符串元素方式

* A:案例演示

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

* 思路：创建新集合方式

public class Demo01_ArrayList {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //创建新集合
        ArrayList newList = new ArrayList();
        //获取老集合的迭代器
        Iterator it = list.iterator();
        //遍历老集合
        while(it.hasNext()) {
            //记住每一个元素
            Object obj = it.next();
            //如果新集合中不包含老集合元素，
            if(!newList.contains(obj)) {
                //添加该元素
                newList.add(obj);
            }
        }
        System.out.println(newList);
    }
}

1.1 去除ArrayList中重复自定义对象元素

* A:案例演示

* 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)

* B:注意事项

* 重写equals() and hashCode()方法

public class Demo02_ArrayList {
    /*
     * 创建新集合将重复元素去掉
     * 1,明确返回值类型,返回ArrayList
     * 2,明确参数列表ArrayList
     * 
     * 分析:
     * 1,创建新集合
     * 2,根据传入的集合(老集合)获取迭代器
     * 3,遍历老集合
     * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
     */
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(new Student("张三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",23));
        list.add(new Student("张三",23));
        ArrayList newList = getSingle(list);
        System.out.println(newList);
        list.remove(new Student("李四", 24));
        System.out.println(list);
    }
    public static ArrayList getSingle(ArrayList list) {
        //创建新集合
        ArrayList newList = new ArrayList();
        //根据传入的集合（老集合)获取迭代器
        Iterator it = list.iterator();
        //遍历老集合
        while(it.hasNext()) {
            //记住每一个元素
            Object obj = it.next();
            //如果新集合中不包含老集合中的元素
            if(!newList.contains(obj)) {
                newList.add(obj);
            }
        }
        return newList;
        
    }
}

package com.se.ArrayList;

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

public class Demo2_ArrayList {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三",18));
        list.add(new Student("李四",19));
        list.add(new Student("王五",20));
        list.add(new Student("张三",18));
        ArrayList newList = new ArrayList();
        Demo(list, newList);
        newList.remove(new Student("王五",20));
        System.out.println(newList);
    }

    public static void Demo(ArrayList list, ArrayList newList) {
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Student stu = (Student)iterator.next();
            if (!(newList.contains(stu))){
                newList.add(stu);
            }
        }
    }
}

1.3 LinkedList的特有功能

* A:LinkedList类概述

* B:LinkedList类特有功能

* public void addFirst(E e)及addLast(E e)

* public E getFirst()及getLast()

* public E removeFirst()及public E removeLast()

* public E get(int index);   

 

 

package com.se.ArrayList;

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

public class Demo03_LinkedList {
    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 7};// arr[2]
        ArrayList arrayList = new ArrayList();   // 数组
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");
        linkedList.addFirst("e");
        linkedList.addFirst("f");
        linkedList.addFirst("g");
        linkedList.addFirst("h");
        linkedList.addFirst("i");
        // 数组查找快，链表查找慢
        // arrayList.get(4);
        Object c = linkedList.get(4);
        System.out.println(c); // e
        Object a = linkedList.removeFirst();
        Object b = linkedList.removeLast();
        System.out.println(a); // i
        System.out.println(a); // a
        Object b1 = linkedList.getLast();
        System.out.println(b1); // b
        // 遍历LinkedList
        Iterator iterator = linkedList.iterator();    //获取迭代器
        while (iterator.hasNext()) {                   // 链表中是否有下一个元素
            System.out.println(iterator.next());
        }
    }
}

1.4  泛型概述和基本使用

* A:泛型概述

　　限定存储的数据的类型

* B:泛型好处

* 提高安全性(将运行期的错误转换到编译期)

* 省去强转的麻烦

* C:泛型基本使用

* <>中放的必须是引用数据类型

* D:泛型使用注意事项

* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)  

package com.jhedu.day16;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo4_Generic {
    public static void main(String[] args) {
        // 限定所有的数据都是学生类
        ArrayList<Student> arrayList = new ArrayList<Student>();
        arrayList.add(new Student("A", 21));
        arrayList.add(new Student("B", 22));
        arrayList.add(new Student("C", 24));
        arrayList.add(new Student("D", 25));
        arrayList.add(new Student("E", 23));
        Iterator<Student> it = arrayList.iterator();
        while (it.hasNext()){
           Student s = it.next();  // 加上了泛型就不用进行强制转换了
            // it.next 只能使用一次
            System.out.println(s.getName() + "..." + s.getAge() );
        }
    }
    public static void demo() {
        // 使用方法泛型的方法就是在类后面加两个尖括号，里面跟引用的数据的类型
        // 你需要什么类型，就放对象数据类型
        // 加上泛型之后，就限定了你的数据类型,前后的泛型必须一致
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        /**
         * 遍历数组
         */
        Iterator<String> it = list.iterator();         // 获取迭代器
        while (it.hasNext()){                  // 集合中是否有下一个元素
            String str = it.next();       // 向下转型为字符串   省去强转的麻烦
            System.out.println(str);     // 获取下一个元素
        }
    }
}

1.5 ArrayList存储字符串和自定义对象并遍历泛型版

* A:案例演示

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

package com.jhedu.day16;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo4_Generic {
    public static void main(String[] args) {
        // 限定所有的数据都是学生类
        ArrayList<Student> arrayList = new ArrayList<Student>();
        arrayList.add(new Student("A", 21));
        arrayList.add(new Student("B", 22));
        arrayList.add(new Student("C", 24));
        arrayList.add(new Student("D", 25));
        arrayList.add(new Student("E", 23));
        Iterator<Student> it = arrayList.iterator();
        while (it.hasNext()){
           Student s = it.next();  // 加上了泛型就不用进行强制转换了
            // it.next 只能使用一次
            System.out.println(s.getName() + "..." + s.getAge() );
        }
    }
    public static void demo() {
        // 使用方法泛型的方法就是在类后面加两个尖括号，里面跟引用的数据的类型
        // 你需要什么类型，就放对象数据类型
        // 加上泛型之后，就限定了你的数据类型,前后的泛型必须一致
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        /**
         * 遍历数组
         */
        Iterator<String> it = list.iterator();         // 获取迭代器
        while (it.hasNext()){                  // 集合中是否有下一个元素
            String str = it.next();       // 向下转型为字符串   省去强转的麻烦
            System.out.println(str);     // 获取下一个元素
        }
    }
}

1.6 泛型类的概述及使用(了解)

* A:泛型类概述<T>

* 把泛型定义在类上

* B:定义格式

* public class 类名<泛型类型1,…>

* C:注意事项

* 泛型类型必须是引用类型

* D:案例演示

* 泛型类的使用

1.7 泛型方法的概述和使用（了解）

* A:泛型方法概述

* 把泛型定义在方法上

* B:定义格式

* public <泛型类型> 返回类型 方法名(泛型类型 变量名)

* C:案例演示

* 泛型方法的使用

1.8 泛型接口的概述和使用（了解）

* A:泛型接口概述

* 把泛型定义在接口上

* B:定义格式

* public interface 接口名<泛型类型>

* C:案例演示

* 泛型接口的使用

1.9 泛型高级之通配符（了解）

* A:泛型通配符<?>

* 任意类型，如果没有明确，那么就是Object以及任意的Java类了

* B:? extends E

* 向下限定，E及其子类

* C:? super E

* 向上限定，E及其父类

1.10 增强for的概述和使用

* A:增强for概述

* 简化数组和Collection集合的遍历

* B:格式：

for(元素数据类型 变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素

}

* C:案例演示

* 数组，集合存储元素用增强for遍历

* D:好处

* 简化遍历

package com.jhedu.day16;

import java.util.ArrayList;
import java.util.Iterator;
public class Demo6_Foreach {
    public static void main(String[] args) {
        //demo();
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");
        arrayList.add("e");
        arrayList.add("f");
        arrayList.add("g");
        // 普通for遍历方式
        for(int i=0; i<arrayList.size();i++){
            System.out.print(arrayList.get(i) + " ");
        }
        System.out.println("++++++++++++++");
        // 迭代器遍历
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            System.out.print(it.next() + " ");
        }
        System.out.println("-------------------");
        // 增强for循环
        for(String s : arrayList){
            System.out.print(s + " ");
        }
    }
    public static void demo() {
        int[] arr = {1,2, 3, 4, 5,6};
        // 普通for循环的遍历
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
        // 增强for循环
        for(int i: arr){
            System.out.println(i );
        }
    }
}

1.11 三种迭代的能否删除

* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常

* 增强for循环不能删除

1.12可变参数的概述和使用（了解）

* A:可变参数概述

* 定义方法的时候不知道该定义多少个参数

* B:格式

* 修饰符 返回值类型 方法名(数据类型…  变量名){}

* C:注意事项：

* 这里的变量其实是一个数组

* 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

package com.jhedu.day16;
public class Demo8_Change {
    public static void main(String[] args) {
        int [] arr = {11,22,33,44,55,66};
        //print(11,arr);
        print(11,22,33,44);
    }
    /*public static void print(int[]arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }*/
   /*public static void print(int...arr) {
      for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i]);
      }
   }*/
    public static void print(int a,int...arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

1.13  集合嵌套之ArrayList嵌套ArrayList

* A:案例演示

* 集合嵌套之ArrayList嵌套ArrayList

package com.jhedu.day16;

import java.util.ArrayList;

/**
 * /* * A:案例演示
 *      * 集合嵌套之ArrayList嵌套ArrayList
 *      * 案例:
 *      * 我们学科,学科又分为若个班级
 *      * 整个学科一个大集合
 *      * 若干个班级分为每一个小集合
 *
 */

//定义一个学科集合，学科里面放的是班级，班级里面放的是学生
public class Demo7_ArrayListDouble {
    public static void main(String[] args) {
        //定义一个学科集合，学科里面放的是班级，班级里面放的是学生
        ArrayList<ArrayList<Student>> list = new ArrayList<>();
        // 第一个班级
        ArrayList<Student> first = new ArrayList<>();// 泛型
        first.add(new Student("zhangsan",14));
        first.add(new Student("lisi",13));
        first.add(new Student("wangwu",17));
        //创建第二个班级
        ArrayList<Student> second = new ArrayList<>();
        second.add(new Student("王五",24));
        second.add(new Student("天气",27));

        //将班级添加到学科集合中
        list.add(first);
        list.add(second);
        //遍历学科集合
        for (ArrayList<Student> a : list) {  //第一种循环
            for(Student s : a){
                System.out.println(s);
            }
        }
    }
}