集合(list)#泛型使用

16.01_集合框架(去除ArrayList中重复字符串元素方式1)

• A:案例演示

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

  • 思路：创建新集合方式

    /** *  A:案例演示 * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同) * 思路：创建新集合方式 */public static void main(String[] args) {    ArrayList list = new ArrayList();    list.add("a");    list.add("a");    list.add("b");    list.add("b");    list.add("b");    list.add("c");    list.add("c");    list.add("c");    list.add("c");    System.out.println(list);    ArrayList newList = getSingle(list);    System.out.println(newList);}/* * 去除重复 * 1,返回ArrayList * 2,参数列表ArrayList */public static ArrayList getSingle(ArrayList list) {    ArrayList newList = new ArrayList();            //创建一个新集合    Iterator it = list.iterator();                  //获取迭代器    while(it.hasNext()) {       //判断老集合中是否有元素        String temp = (String)it.next();    //String中重写了equals()方法//将每一个元素临时记录住        if(!newList.contains(temp)) {           //如果新集合中不包含该元素            newList.add(temp);                      //将该元素添加到新集合中        }    }    return newList;                                 //将新集合返回}

    ps:

  • ArrayList的构造方法： ArrayList list= new ArrayList()////构造一个初始容量为10的object类型的数组

  •  遍历集合方法： 1，通过迭代器遍历集合   2，普通for循环(利用size(),get())遍历集合//这种遍历只支持list集合,set集合不可以,因为set集合无索引

  • public static void main(String[] args) {ArrayList list = new ArrayList();//构造一个初始容量为10的object类型的组list.add(new Person("张三", 23));list.add(new Person("李四", 24));list.add(new Person("王五", 25));list.add(new Person("赵六", 26));Iterator it = list.iterator();//利用迭代器，遍历集合while(it.hasNext()) {Person p = (Person)it.next();System.out.println(p.getName() + "," + p.getAge());}for(int i = 0; i < list.size(); i++) {//普通for循环：size()，get()Person p = (Person)list.get(i);System.out.println(p.getName() + "," + p.getAge());}}}

16.02_集合框架(去除ArrayList中重复自定义对象元素)

• A:案例演示
  • 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
• B:注意事项
  • 自定义对象类中要重写equals()方法的
  • contains和remove方法底层依赖与equals方法,如果没有重写equals方法,比较的是对象的地址值,重写之后比较的是对象的属性值

  • 去除ArrayList中重复自定义对象元素的代码如同16.01，注意自定义对象类中要重写equals()方法

16.03_集合框架(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);

  • LinkedList list = new LinkedList();list.addFirst("a");list.addFirst("b");list.addFirst("c");list.addFirst("d");//在第一个位置添加list.addLast("e");//在末尾追加System.out.println(list);//[d,c,b,a,e]Object obj1 = list.getFirst();//获取集合中的第一个元素System.out.println(obj1);//dObject obj2 = list.getLast();//获取集合中的最后一个元素System.out.println(obj2);//e//获取元素，集合中元素不会改变System.out.println(list);Object obj3 = list.removeFirst();//删除集合中的第一个元素,并返回删除的元素System.out.println(obj3);//dObject obj4 = list.removeLast();//删除集合中的最后一个元素System.out.println(obj4);System.out.println(list);}**************************************[d, c, b, a, e]de[d, c, b, a, e]de[c, b, a]

16.04_集合框架(栈和队列数据结构)

• 栈
  • 先进后出
• 队列
  • 先进先出

16.05_集合框架(用LinkedList模拟栈数据结构的集合并测试)

• A:案例演示

  • 需求：请用LinkedList模拟栈数据结构的集合，并测试
  • 创建一个类将Linked中的方法封装

  • //对方法进行封装public class Stack {    private LinkedList list = new LinkedList();     //创建LinkedList对象    public void in(Object obj) {        list.addLast(obj);                          //封装addLast()方法    }    public Object out() {        return list.removeLast();                   //封装removeLast()方法    }    public boolean isEmpty() {        return list.isEmpty();                      //封装isEmpty()方法    }}

  •   //测试                                                                                                             Stack s = new Stack();s.in("a");s.in("b");s.in("c");s.in("d");while(!s.isEmpty()) {System.out.println(s.out());}  *************************  dcba    

16.06_集合框架(泛型概述和基本使用)

• A:泛型概述
• B:泛型好处
  • 提高安全性(将运行期的错误转换到编译期)
  • 省去强转的麻烦（防止出现类型转换异常）
• C:泛型基本使用
  • <>中放的必须是引用数据类型
• D:泛型使用注意事项
  • 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

16.07_集合框架(ArrayList存储字符串和自定义对象并遍历泛型版)

• A:案例演示
  • ArrayList存储字符串并遍历泛型版

  • ArrayList存储自定义对象并遍历泛型版：

  • ArrayList<Person> list = new ArrayList<>();//1.7版本出现,菱形泛型//明确集合中存放元素的类型，添加时：只能添加该类型或该类型的子类型list.add(new Person("张三", 23));list.add(new Person("李四", 24));list.add(new Person("王五", 25));//有泛型集合的迭代：Iterator<Person> it = list.iterator();while(it.hasNext()) {Person p = it.next();/*省去了强转的麻烦，因为泛型的存在，集合中存取的指定类型的对象，那么获取对象时就是该类型的对象，所以不必强制转换了*/System.out.println(p.getName() + "," + p.getAge());}}**************************************张三,23李四,24王五,25

  • ps:1,泛型前面和后面的数据类型必须一致,或者可以省略后面(菱形泛型)* ArrayList<Object> list = new ArrayList<Person>();//这样是错的2,泛型可以定义成Object,但是没有意义，

16.08_集合框架(泛型的由来)

• A:案例演示
  • 泛型的由来:通过Object转型问题引入
  • 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在类型转换异常(ClassCastException)，所以Java提供了泛型来解决这个安全问题。

  • ArrayList list2 = new ArrayList<>();//不添加泛型，即集合中可存取Object类型(任意类型)对象list2.add("abc");list2.add(123);list2.add(new Person("张三", 23));//此时list2集合中存放了String型，int型，和自定义引用类型的对象Iterator it = list2.iterator();while(it.hasNext()) {//遍历集合Person p = (Person)it.next()；
    System.out.println(p.getName() + "," + p.getAge());}}
    /*(Person)it.next()强制类型转换，list2中有三种不同类型的对象，明显String型，int型是不能转化成自定义引用类型的。所以会造成类型转换异常。以至于，需要利用泛型明确集合中元素类型，防止出现类型转换异常*/
    

  • ps:@SuppressWarnings({ "rawtypes", "unchecked" })//去除黄色提示,

16.09_集合框架(泛型类的概述及使用)

• A:泛型类概述
  • 把泛型定义在类上,创建该类对象时，为泛型赋值。
  • 好处：把运行时的错误，提前到编译期间。
• B:定义格式
  • public class 类名<泛型类型1,…>
• C:注意事项
  • 泛型类型必须是引用类型
• D:案例演示
  • 泛型类的使用

16.10_集合框架(泛型方法的概述和使用)

• A:泛型方法概述
  • 把泛型定义在方法上
• B:定义格式
  • public <泛型类型> 返回类型 方法名(泛型类型 变量名)
• C:案例演示
  • 泛型方法的使用

  • public class Tool<W> {//泛型类，创建Tool对象的时候给W传值(W是个变量，接收引用类型)。private W e;public W getObj() {return e;}public void setObj(W e) {//Ojbect obj = new Student();this.e = e;}public void show(W w) {//泛型方法System.out.println(w);//非静态方法由对象来调用，在创建Tool对象时给W赋值了，当调用show(W w)时W是有值得}public static<T> void print(T t) {//静态方法的泛型不能和普通方法泛型一样System.out.println(t);//静态方法是随着类的加载而加载的。而在类加载时还没创建对象}//静态方法拥有自己的泛型，在调用静态方法时为泛型赋值。}

  • //NO.1Tool<Student> t = new Tool<Student>();/*创建Tool对象时，指明泛型为：自定义类型Student，所以上面代码中的W都换成了Student*/t.setObj(new Student("张三", 23));Student s = t.getObj();System.out.println(s);

  • //NO.2Tool<String> t = new Tool<>();
    /*创建Tool对象时，指明泛型为：String类型，所以上面代码中的W都换成了String*/
    t.show("abc");
    Tool.print("abc");//调用上面代码中的静态方法，调用时指明泛型，（因传入的是字符串）所以T为String
    

16.11_集合框架(泛型接口的概述和使用)

• A:泛型接口概述
  • 把泛型定义在接口上
• B:定义格式
  • public interface 接口名<泛型类型>
• C:案例演示
  • 泛型接口的使用

  • interface Inter<T> {//定义泛型接口，在实现时可指定泛型类型public void show(T t);}public class Demo implements Inter<String>{//开发推荐用第一种,实现接口的时候,你已经可以明确具体是什么类型了@Overridepublic void show(String t) {System.out.println(t);}}

16.12_集合框架(泛型高级之通配符)

• A:泛型通配符<?>
  • 任意类型，如果没有明确，那么就是Object以及任意的Java类了
  • eg:ArrayList<?> list1 = new ArrayList<>();
  • 不确定后面返回什么类型的泛型时使用
• B:? extends E
  • 向下限定，E及其子类（？是子类E是父类）可以添加E类型以及E的子类型,E是上边界(固定上边界)
• C:? super E
  • 向上限定，E及其父类（E是子类？是父类）

ArrayList<Person> list1 = new ArrayList<>();list1.add(new Person("张三", 23));list1.add(new Person("李四", 24));list1.add(new Person("王五", 25));ArrayList<Student> list2 = new ArrayList<>();list2.add(new Student("马哥", 18));list2.add(new Student("马哥粉丝团团长", 20));list2.add(new Student("马哥粉丝团秘书", 16));list1.addAll(list2);//将一个集合添加到另一个类中/* * list1存放的是Person类型对象，list2存放的是Student类型对象。 *因list1中对象和list2集合对象存在? extends E关系(Student继承于Person)，才能将list2中元素添加到list1中 */System.out.println(list1); **************************************[Person [name=张三, age=23], Person [name=李四, age=24], Person [name=王五, age=25], Person [name=马哥, age=18], Person [name=马哥粉丝团团长, age=20], Person [name=马哥粉丝团秘书, age=16]]

16.13_集合框架(增强for的概述和使用)

• A:增强for概述
  • 简化数组和Collection集合的遍历
  • 快捷生成foreach：先写：fore 再按：alt+/
• B:格式：

• for(元素数据类型 变量 : 数组或者Collection集合) {    使用变量即可，该变量就是元素}

• C:案例演示
  • 数组，集合存储元素用增强for遍历
• D:好处
  • 简化遍历

  • 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);}int[] arr = {11,22,33,44,55};for (int i : arr) {//遍历数组System.out.println(i);}}**********************************abcd1122334455

16.14_集合框架(ArrayList存储字符串和自定义对象并遍历增强for版)

• A:案例演示

  • ArrayList存储字符串并遍历增强for版

  • ArrayList<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");list.add("d");for(String s : list) {//临时变量的数据类型和泛型一致,如果没有泛型默认Object    System.out.println(s);}

16.15_集合框架(三种迭代的能否删除)

• 普通for循环,可以删除,但是索引要--
• 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
• 增强for循环不能删除

16.16_集合框架(静态导入的概述和使用)

• A:静态导入概述
• B:格式：
  • import static 包名….类名.方法名;
  • 可以直接导入到方法的级别
• C:注意事项
  • 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

  • import static java.util.Arrays.sort;//静态导入方法import static java.util.Arrays.toString;public class Demo08_StaticImport {/** * @param args * Jdk1.5的新特性 * 1,自动拆装箱 * 2,泛型 * 3,增强for循环 * 4,静态导入:其实导入的是静态的方法,只要是静态的方法都可以用静态导入(开发严重不推荐) */public static void main(String[] args) {int[] arr = {55,44,33,22,11};//Arrays类sort(arr);//排序，直接用方法//System.out.println(toString(arr));//数组转换成字符串并打印,和其他toString方法冲突}}

16.17_集合框架(可变参数的概述和使用)

• A:可变参数概述
  • 定义方法的时候不知道该定义多少个参数
• B:格式
  • 修饰符 返回值类型 方法名(数据类型… 变量名){}
• C:注意事项：
  • 这里的变量其实是一个数组
  • 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

  • public static void print(int x,int ... arr) {//可变参数要在最后for (int i : arr) {//int ... arr = int[] arrSystem.out.println(i);}}
    

  • public static void demo1() {int[] arr = {11,22,33,44,55};print(arr);print(11,22,33,44,55);//可以调用含可变参数的方法}/*public static void print(int[] arr) {//不带可变参数for (int i : arr) {System.out.println(i);}}*///带可变参数和不带可变参数的方法不可以同时存在public static void print(int ... arr) {//可变参数,其实就是一个可以变化的数组for (int i : arr) {//int ... arr = int[] arrSystem.out.println(i);}}}

16.18_集合框架(Arrays工具类的asList()方法的使用)

• A:案例演示
  • Arrays工具类的asList()方法//把数组转换成集合
  • Collection中toArray(T[] a)泛型版的集合转数组

  • int[] arr = {11,22,33,44,55};List<int[]> list = Arrays.asList(arr);/*基本数据类型数组转集合：把数组当做一个对象，存在集合中，所以泛型：int[]*/System.out.println(list);Integer[] arr2 = {11,22,33,44,55};//11,22,33,44,55是Integer类型,自动装箱List<Integer> list2 = Arrays.asList(arr2);//把数组转换成集合,必须是引用数据类型的数组,否则会将整个数组当作一个对象System.out.println(list2);*************************************[[I@15db9742][11, 22, 33, 44, 55]

    
    ps:数组转换成集合不能改变长度(add()方法，remove()不可用),但是可以应用集合中其他的方法

16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)

• A:案例演示
  • 集合嵌套之ArrayList嵌套ArrayList

  • // 集合嵌套集合，类似于数组的嵌套ArrayList<ArrayList<Student>> list = new ArrayList<>();//集合中添加集合：把整个集合当做泛型//第一个班级ArrayList<Student> first = new ArrayList<>();first.add(new Student("马哥", 18));first.add(new Student("马哥第一批粉丝团1", 88));first.add(new Student("马哥第一批粉丝团2", 20));//第二个班级ArrayList<Student> second = new ArrayList<>();second.add(new Student("马哥第二批粉丝团1", 5));second.add(new Student("马哥第二批粉丝团2", 100));//将第一个班级和第二个班级添加到list里list.add(first);list.add(second);for(ArrayList<Student> li : list) {for(Student s : li) {System.out.print(s + " ");}System.out.println();}}*****************************************Person [name=马哥, age=18] Person [name=马哥第一批粉丝团1, age=88] Person [name=马哥第一批粉丝团2, age=20] Person [name=马哥第二批粉丝团1, age=5] Person [name=马哥第二批粉丝团2, age=100] 

    
    
    

编程练习：

对集合中添加的元素排序

ArrayList<String> list1 = new ArrayList<>();list1.add("b");list1.add("f");list1.add("e");list1.add("c");list1.add("a");list1.add("d");sort(list1);System.out.println(list1);// a, b, c, d, e, fArrayList<Integer> list2 = new ArrayList<>();list2.add(5);list2.add(8);list2.add(3);list2.add(1);list2.add(4);sort(list2);System.out.println(list2); //1,3,4,5,8}//public static <T> void sort(ArrayList<T> list)/*T不确定是什么类型，不一定都有compareTo()方法，所以会报错*compareTo()方法必须是Comparable的子类才具备。*所以要保证T是Comparable的子类，即<T extends Comparable<T>>*///无论是继承接口还是继承类都是extendspublic static <T extends Comparable<T>> void sort(ArrayList<T> list){T m;for(int i=0;i<list.size();i++){for(int j=i+1;j<list.size();j++){if(list.get(i).compareTo(list.get(j)) > 0){m=list.get(i);list.set(i, list.get(j));list.set(j, m);}}}}********************************************[a, b, c, d, e, f][1, 3, 4, 5, 8]

16.20_day16总结

• 把今天的知识点总结一遍。