Java 集合框架 02

集合框架· LinkedList 和泛型

去除ArrayList中重复字符串元素

* A：案例演示
　　* 需求：ArrayList去除集合中字符串的重复值（相同内容的字符串）
　　* 思路：创建新集合方式

package com.heima.list;

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

public class Demo1_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("b");
        list.add("c");
        list.add("d");

        ArrayList newList = getSingle(list);
        System.out.println(newList);
    }
    /*
     * 创建新集合将重复元素去掉
     * 1、明确返回值类型：ArrayList
     * 2、明确参数列表：ArrayList list
     * 
     * 分析：
     * 1、创建新的集合
     * 2、根据获取的集合（老集合）获取迭代器
     * 3、遍历老集合
     * 4、通过新集合判断是否包含老集合中的元素，如果包含就不添加，如果不包含就添加
     */
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList(); // 创建新集合
        Iterator it = list.iterator(); // 获取迭代器
        
        while (it.hasNext()) { // 遍历老集合
            Object object = (Object) it.next(); // 记录每个元素
            if (!newList.contains(object)) { // 如果新集合中不包含老集合中的元素
                newList.add(object); // 就将该元素添加到新集合中
            }
        }
        return newList;    // 返回新集合
    }
}

ArrayList

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

* A：案例演示：
　　* 需求：ArrayList去除集合中自定义对象元素的重复值（对象的成员变量值相同）

* B：注意事项
　　* 重写equals() 方法

@Override
    public boolean equals(Object obj) {
        Person person =(Person)obj;
        return this.name.equals(person.name) && this.age == person.age;
    }

Person类内重写后的equals 方法

package com.heima.list;

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

import com.heima.bean.Person;

public class Demo2_ArrayList {

    public static void main(String[] args) {
        ArrayList list = new ArrayList(); // 创建集合对象
        list.add(new Person("张三", 23));
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));

        ArrayList newList = getSingle(list); // 调用方法去除重复
        System.out.println(newList);

        // remove() 方法底层依赖的也是equals()方法
        list.remove(new Person("张三", 23));
        System.out.println(list);
    }

    // contains()方法底层依赖equals方法，equals未重写前是判断地址值
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList(); // 创建新集合
        Iterator it = list.iterator(); // 获取迭代器

        while (it.hasNext()) { // 遍历老集合
            Object object = (Object) it.next(); // 记录每个元素
            if (!newList.contains(object)) { // 如果新集合中不包含老集合中的元素
                newList.add(object); // 将该元素添加到新集合中
            }
        }
        return newList;
    }
}

ArrayList

LinkedList的特有功能

* A：LinkedList类概述

* B：LinkedList类特有功能

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

public E getFirst()
public E getLast()

public E removeFirst()
public E removeLast()

public E get(int index)

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }


    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

get() 方法源码

package com.heima.list;

import java.util.LinkedList;

public class Demo3_LinkedList {

    public static void main(String[] args) {
        LinkedList list = new LinkedList(); // 创建LinkedList
        list.addFirst("a"); // 在第一个位置添加
        list.addFirst("b");
        list.addFirst("c");
        list.addFirst("d");
        list.addFirst("e");
        list.addFirst("f");
        list.addLast("m");

        System.out.println(list); // 打印链表
        System.out.println(list.getFirst()); // 获取第一个值
        System.out.println(list.getLast()); // 获取最后一个值
        System.out.println(list.removeFirst()); // 从链表中移除第一个值并返回该值
        System.out.println(list.removeLast()); // 从链表中移除最后一个值并返回该值
        System.out.println(list); // 打印链表

        System.out.println(list.get(1)); // 按照索引获取值

    }
}

LinkedList

栈和队列数据结构

* 栈
　　* 先进后出

* 队列
　　* 先进先出

用LinkedList模拟栈数据结构

* A：案例演示
　　* 需求：请用LinkedList模拟站数据结构的集合，并测试
　　* 创建一个类将LinkedList中的方法封装

package com.heima.bean;

import java.util.LinkedList;

public class Stack {
    private LinkedList list = new LinkedList();    
    
    public void in(Object obj) {
        // 模拟进栈
        list.addLast(obj);
    }
    
    public Object out() {
        // 模拟弹栈
        return list.removeLast();
    }
    
    public boolean isEmpty() {
        // 判断是否为空
        return list.isEmpty();
    }
}

封装后 stack类

package com.heima.list;

import java.util.LinkedList;
import com.heima.bean.Stack;

public class Demo4_LinkedList {

    public static void main(String[] args) {
        // 用LinkedList模拟栈结构

        // demo1(); // 未封装
        // demo2(); // 已封装
    }

    public static void demo2() {
        Stack s = new Stack();
        s.in("a"); // 进栈
        s.in("b");
        s.in("c");
        s.in("d");

        while (!s.isEmpty()) { // 判断栈结构是否为空
            System.out.println(s.out()); // 弹栈
        }
    }

    public static void demo1() {
        LinkedList list = new LinkedList();
        list.addLast("a");
        list.addLast("b");
        list.addLast("c");
        list.addLast("d");

//        System.out.println(list.removeLast());
//        System.out.println(list.removeLast());
//        System.out.println(list.removeLast());
//        System.out.println(list.removeLast());

        while (!list.isEmpty()) { // 判断集合是否为空
            System.out.println(list.removeLast()); // 如果不为空就弹栈一次
        }
    }
}

LinkedList

泛型（generic）概述和基本使用

* A：泛型概述

* B：泛型好处
　　* 提高安全性（将运行期的错误转移到编译期）
　　* 省去强转的麻烦

* C：泛型的基本使用
　　* < > 中放的必须是引用数据类型

* D：泛型使用注意事项
　　* 前后泛型必须一致，或者后面的泛型可以省略不写（JDK1.7的新特性菱形泛型）

package com.heima.generic;

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

import com.heima.bean.Person;
import com.heima.bean.Student;

public class Demo1_Generic {
    public static void main(String[] args) {
        // demo1(); // 不使用泛型
        // demo2(); // 使用泛型
    }

    public static void demo2() {
        ArrayList<Person> list = new ArrayList<Person>(); // 要保证前后的泛型一致，泛型可以是Object，但一般不这么定义
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));

        Iterator it = list.iterator();
        while (it.hasNext()) {
            Person stu = (Person) it.next(); // 每一次循环，next方法只能调用一次
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }

    public static void demo1() {
        ArrayList list = new ArrayList();
        list.add(110);
        list.add(true);
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));

        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object object = (Object) it.next();
            if (object instanceof Person) {
                Person p = (Person) object; // 向下转型
                System.out.println(p.getName() + "..." + p.getAge());
            }
            System.out.println(object);
        }
    }
}

generic

ArrayList存储字符串和自定义对象并遍历

* A：案例演示
　　* ArrayList存储字符串并遍历·泛型版

package com.heima.generic;

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

import com.heima.bean.Person;

public class Demo2_Generic {

    public static void main(String[] args) {
        // demo1();
        // demo2();
    }

    public static void demo2() {
        ArrayList<Person> list = new ArrayList<Person>(); // 创建泛型为Person的集合对象
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));

        Iterator<Person> it = list.iterator(); // 创建泛型为Person的迭代器
        while (it.hasNext()) {
            Person person = (Person) it.next();    // 将迭代器中的每一个元素用person记录
            System.out.println(person.getName() + "..." + person.getAge());
        }
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<String>(); // 创建泛型为String的集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator(); // 获取泛型为String的迭代器
        while (it.hasNext()) {
            String string = (String) it.next();
            System.out.println(string);
        }
    }
}

generic

泛型的由来

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

package com.heima.bean;

public class Tool {
    private Object obj;

    public Tool() {
        super();
    }

    public Tool(Object obj) {
        super();
        this.obj = obj;
    }

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }
    
}

Tool类

package com.heima.generic;

import com.heima.bean.Student;
import com.heima.bean.Tool;
import com.heima.bean.Worker;

public class Demo3_Generic {
    public static void main(String[] args) {
        Tool t = new Tool(); // 创建工具类对象
        t.setObj(new Student("张三", 23));

        Worker w = (Worker) t.getObj(); // java.lang.ClassCastException，类型转换异常
        System.out.println(w);
    }
}

generic

泛型类的概述及使用

* A：泛型类概述<T>
　　* 把泛型定义在类上

* B：定义格式
　　* public class 类名<泛型类型1, ...>

* C：注意事项
　　* 泛型类型必须是引用数据类型

* D：案例演示
　　* 泛型类的使用

package com.heima.bean;

public class Tool<T> {
    private T t;

    public Tool() {
        super();
    }

    public Tool(T t) {
        super();
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setObj(Object obj) {
        this.t = t;
    }
    
}

Tool类

泛型方法的概述和使用

* A：泛型方法概述
　　* 把泛型定义在方法上

* B：定义格式
　　* public <泛型类型> 返回类型方法名 (泛型类型变量名)

* C：案例演示
　　* 泛型方法的使用

package com.heima.bean;

public class Tool<T> {
    private T t;

    public Tool() {
        super();
    }

    public Tool(T t) {
        super();
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setObj(Object obj) {
        this.t = t;
    }
    
    public<Q> void show(Q q) { // 方法泛型需要与类的泛型一致,如果不一致就需要在方法上声明自己的泛型
        System.out.println(q);
    }
    
    public static<Q>  void print(Q q) {    // 静态方法，类名调用，随着类的加载而加载，此时T还没有被赋值，因此必须要自己声明泛型
        System.out.println(q);
    }
}

Tool

泛型接口的概述和使用

* A：泛型接口概述
　　* 把泛型定义在接口上

* B：定义格式
　　* public interface 接口名<泛型类型>

* C：案例演示
　　* 泛型接口的使用

package com.heima.generic;

public class Demo4_Generic {
    public static void main(String[] args) {
        Demo1 d1 = new Demo1();    // 推荐用这种
        d1.show("a");
        
        Demo2<String> d2 = new Demo2<>();
        d2.show("b");
    }
}

interface Inter<T> { // 定义了接口泛型
    public void show(T t);
}

class Demo1 implements Inter<String> { // 推荐这种

    @Override
    public void show(String t) {
        System.out.println(t);
    }

}

class Demo2<T> implements Inter<T> { // 没有必要再实现接口的时候给自己的类加泛型

    @Override
    public void show(T t) {
        System.out.println(t);
    }

}

generic

泛型高级之通配符

* A：泛型通配符 <?>
　　* 任意类型，如果没用明确，那么就是Object以及任意Java类

* B：? extends E
　　* 向下限定，E及其子类

* C：? super E
　　* 向上限定，E及其父类

package com.heima.generic;

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

import com.heima.bean.Person;
import com.heima.bean.Student;

public class Demo5_Generic {
    
    public static void main(String[] args) {
        //List<Object> list = new ArrayList<String>();    // 如果前面泛型为Object那么前后就不一致了
        //List<?> list = new ArrayList<String>();    // 当右边的泛型是不确定的时候，左边可指定为？
        
        ArrayList<Person> list1 = new ArrayList<Person>();
        list1.add(new Person("张三",23));
        list1.add(new Person("李四",24));
        list1.add(new Person("王五",25));
        list1.add(new Person("赵六",26));
    
        ArrayList<Student> list2 = new ArrayList<Student>();
        list2.add(new Student("周七", 27));
        
        list1.addAll(list2);    // 向存储Person类对象的集合中存储 由其子类Student实例化的对象
        System.out.println(list1);
        
        // list2.addAll(list1); // 将父类添加到子类中，会报错
    }
}

View Code

增强for循环的概述和使用

* A：增强for循环概述
　　* 简化数组和Collection集合的遍历

* B：格式

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

* C：案例演示
　　* 数组，集合存储元素用增强for循环遍历

* D：好处
　　* 简化遍历

package com.heima.jdk5;

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

import com.heima.bean.Person;

public class Demo1_Foreach {
    public static void main(String[] args) {
    // demo1(); // 遍历数组
    // demo2(); // 遍历自定义类的集合

    public static void demo2() {
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));

        for (Person person : list) {
            System.out.println(person.getName() + "..." + person.getAge());
        }
    }

    public static void demo1() {
        int[] arr1 = { 11, 22, 33, 44, 55 };
        for (int i : arr1) { // 底层为迭代器实现, fore 快速敲出
            System.out.println(i);
        }

        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        for (String string : list) { // 快捷键 fore
            System.out.println(string);
        }
    }
}

fore

三种迭代能否删除

* A：普通for循环，可以删除，但是索引要 - -

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

* C：增强for循环不能删除

package com.heima.jdk5;

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

public class Demo6_Foreach {

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

        // demo1(list); // 普通for循环删除    
        // demo2(list); // while循环迭代器删除，迭代器变量定义在外
        // demo3(list); // for循环迭代器删除，迭代器变量定义在内
        // demo4(list); // 增强for循环

    }

    public static void demo4(ArrayList<String> list) {
        // 3、增强for循环， 不能用来删除，只能用来遍历
        for (String string : list) {
            if ("b".equals(string)) {
                // list.remove("b"); // 底层由迭代器实现，会出现并发修改异常
            }
        }
    }

    public static void demo3(ArrayList<String> list) {
        for (Iterator<String> it2 = list.iterator() ; it2.hasNext();) {
            if ("b".equals(it2.hasNext())) {
                it2.remove();
            }
        }
        System.out.println(list);
    }

    public static void demo2(ArrayList<String> list) {
        // 2、迭代器删除,注意一定要使用迭代器的删除方式，避免出现并发修改异常
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String string = (String) it.next();
            if ("b".equals(string)) {
                it.remove();
            }
        }
        System.out.println(list);
    }

    public static void demo1(ArrayList<String> list) {
        // 1、普通for循环删除，索引要 --
        for (int i = 0; i < list.size(); i++) {
            if ("b".equals(list.get(i))) {
                list.remove(i--); // 注意i--，保证相邻的要删的元素不被漏删
            }
        }
        System.out.println(list);
    }
}

fore

静态导入的概述和使用

* A：静态导入的概述

* B：格式
　　* import static 包名 . 类名 . 方法名;
　　* 可以直接导入道方法的级别

* C：注意事项
　　* 方法必须是静态的，如果有多个同名的静态方法，容易混淆，这个时候如果要用，必须加前缀
　　* 由此可见，意义不大，所以一般不用，但是要能看得懂

package com.heima.jdk5;

import static java.util.Arrays.sort;
import static java.util.Arrays.toString;


public class Demo2_StaticImport {
    public static void main(String[] args) {
        int[] arr = { 55, 22, 33, 44, 11 };
        sort(arr);    // 使用Arrays类的sort排序
        // System.out.println(toString(arr)); // 此时Arrays的toString和本类的toString冲突了
    }
}

ImportStatic

可变参数的概述和使用

* A：可变参数的概述
　　* 定义方法的时候不知道该定义多少个参数

* B：格式
　　* 修饰符返回值类型方法名(数据类型 ... 变量名) { }

* C：注意事项
　　* 这里的变量其实是一个数组
　　* 如果一个方法有可变参数，那么，可变参数位于最后

package com.heima.jdk5;

public class Demo3_ChangeableArgs {
    public static void main(String[] args) {
        int[] arr = { 11, 22, 33, 44, 55 };
        print(2,arr);    // 只打印了数组中的内容
        System.out.println("-----------------");
        print(2, 11, 22, 33, 44, 55);    // 2没被打印
    }

    /*
     * public static void print(int[] arr) { for (int i : arr) {
     * System.out.println(i); } }
     */

    
      public static void print(int x, int ... arr) { // 可变参数其实是一个数组,可变参数必须放在最后 
          for (int i : arr) {
              System.out.println(i); 
          } 
      }

     
}

ChangeableArgs

Arrays工具类的asList() 方法的使用

* A：案例演示
　　* Arrays工具类的asList() 方法的使用，将数组转换为集合
　　* Collection中toArray(T[ ] t) 泛型版的集合转数组

package com.heima.jdk5;

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

public class Demo4_AsList {
    
    public static void main(String[] args) {
        // demo1();
        // demo2();
        // demo3();
    }

    public static void demo3() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
    
        String[] arr = list.toArray(new String[4]);        // 当转换数组时，数组的长度如果是小于等于集合的size，转换后的数组长度等于集合的size
        for (String string : arr) {                        // 如果数组的长度大于了size，分配的长度就是指定值
            System.out.println(string);
        }
    }

    public static void demo2() {
        // int[] arr = {11,22,33,44};
        // List<int[]> list = Arrays.asList(arr);
        Integer[] arr = {11,22,33,44};
        List<Integer> list = Arrays.asList(arr);    // 如果arr存储的是基本数据类型，那么整个arr会被当作一个元素转换成集合，而不会自动装箱
        System.out.println(list);
    }

    public static void demo1() {
        String[] arr = { "a", "b", "c" };
        List<String> list = Arrays.asList(arr);    // 将数组转换成集合,虽然不能增删元素，但是可以用集合的思想操作数组，可以使用集合的其他方法
        //list.add("d");    // 不能增加或减少元素
        System.out.println(list);
    }
}

asList

集合嵌套之ArrayList嵌套ArrayList

* A：案例演示
　　* 集合嵌套之ArrayList嵌套ArrayList

package com.heima.jdk5;

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

import com.heima.bean.Person;

public class Demo5_ArrayListArrayList {

    public static void main(String[] args) {
        ArrayList<ArrayList<Person>> list = new ArrayList<ArrayList<Person>>();

        ArrayList<Person> first = new ArrayList<Person>();
        first.add(new Person("杨幂", 30));
        first.add(new Person("李冰冰", 33));
        first.add(new Person("范冰冰", 20));

        ArrayList<Person> second = new ArrayList<Person>();
        second.add(new Person("黄晓明", 31));
        second.add(new Person("陈坤", 32));

        list.add(first);
        list.add(second);

        for (ArrayList<Person> a : list) {
            for (Person p : a) { // 循环嵌套循环 来遍历 集合嵌套集合
                System.out.println(p);
            }
        }
    }
}

ArrayList

posted @ 2020-04-09 20:03 小么VinVin 阅读(134) 评论(0) 编辑收藏举报

刷新页面返回顶部

YuanChuZiWen

Less Is More

Java 集合框架 02

集合框架· LinkedList 和泛型

去除ArrayList中重复字符串元素

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

LinkedList的特有功能

栈和队列数据结构

用LinkedList模拟栈数据结构

泛型（generic）概述和基本使用

ArrayList存储字符串和自定义对象并遍历

泛型的由来

泛型类的概述及使用

泛型方法的概述和使用

泛型接口的概述和使用

泛型高级之通配符

增强for循环的概述和使用

三种迭代能否删除

静态导入的概述和使用

可变参数的概述和使用

Arrays工具类的asList() 方法的使用

集合嵌套之ArrayList嵌套ArrayList

公告

YuanChuZiWen

Less Is More

Java 集合框架 02

集合框架· LinkedList 和 泛型

去除ArrayList中重复字符串元素

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

LinkedList的特有功能

栈和队列数据结构

用LinkedList模拟栈数据结构

泛型（generic）概述和基本使用

ArrayList存储字符串和自定义对象并遍历

泛型的由来

泛型类的概述及使用

泛型方法的概述和使用

泛型接口的概述和使用

泛型高级之通配符

增强for循环的概述和使用

三种迭代能否删除

静态导入的概述和使用

可变参数的概述和使用

Arrays工具类的asList() 方法的使用

集合嵌套之ArrayList嵌套ArrayList

公告

集合框架· LinkedList 和泛型