17 ArrayLis/Vector/LinkedList/泛型

最新推荐文章于 2018-08-01 16:06:49 发布

guoyoubuji

最新推荐文章于 2018-08-01 16:06:49 发布

阅读量376

点赞数

分类专栏： java系统学习

本文链接：https://blog.csdn.net/guoyoubuji/article/details/53327045

版权

java系统学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

本文深入讲解Java集合框架的核心概念和技术，包括ArrayList、LinkedList等集合类的使用技巧，泛型的基本原理及其高级应用，如通配符等。同时，文章还介绍了如何利用泛型提升代码的安全性和减少强制类型转换的麻烦。

摘要由CSDN通过智能技术生成

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

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();            //将每一个元素临时记录住
                    if(!newList.contains(temp)) {               //如果新集合中不包含该元素
                        newList.add(temp);                      //将该元素添加到新集合中
                    }
                }
                return newList;                                 //将新集合返回
            }

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

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

public static void main(String[] args) {
    List list=new ArrayList();
    List newlist=new ArrayList();
    list.add(new People("henry",23));
    list.add(new People("wendy",23));
    list.add(new People("calin",23));
    list.add(new People("king",23));
    list.add(new People("wendy",23));
    Iterator it=list.iterator();
    while (it.hasNext()){
        Object o=it.next();
        if(!newlist.contains(o)){
            newlist.add(o);
        }
    }
    System.out.println(newlist);
}
}

结果仍然有重复的对象，查找原因发现contains原码是用equals方法，

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;

}前面学过一个对象如果没有重写equals方法，如果直接用equals方法，对比的是两个数的地址值，如果重写后，对比的是属性值

* B:注意事项
* 重写equals()方法的
Contains方法和remove方法底层都是用的equals方法，如果不重写，不会发达预期效果

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);

Get 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;
        }

04_集合框架(栈和队列数据结构)(掌握)

栈
- 先进后出
队列
- 先进先出

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()方法
                }
            }

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

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

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

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

08_集合框架(泛型的由来)(了解)

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

ArrayList<People> list = new ArrayList<People>();
        list.add(110);
        list.add(true);不加泛型，在遍历强转的时候要报错，加了之后在编译器就会被报错。
        list.add(new People("张三", 23));
        list.add(new People("李四", 24));

        Iterator<People> it = list.iterator();
        while(it.hasNext()) {
            //System.out.println(it.next());

            //System.out.println(it.next().getName() + "..." + it.next().getAge());//next方法只能调用一次,如果调用多次会将指针向后移动多次
            People p = it.next();           
            System.out.println(p.getName() + "..." + p.getAge());
        }
    }

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

A:泛型类概述
- 把泛型定义在类上
B:定义格式
- public class 类名<泛型类型1,…>
C:注意事项
- 泛型类型必须是引用类型
D:案例演示
- 泛型类的使用

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

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

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

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

12_集合框架(泛型高级之通配符)(了解)

A:泛型通配符

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

A:增强for概述
- 简化数组和Collection集合的遍历
B:格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:案例演示
- 数组，集合存储元素用增强for遍历
D:好处
- 简化遍历

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) {
                System.out.println(s);
            }

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

普通for循环,可以删除,但是索引要–
迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
增强for循环不能删除(底层是迭代器，但却不能只能使用list,remove,会报出并发异常)

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

        //1,普通for循环删除,索引要--
        /*for(int i = 0; i < list.size(); i++) {
            if("b".equals(list.get(i))) {
                list.remove(i--);                           //通过索引删除元素
            }
        }*/

        //2,迭代器删除
        /*Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            if("b".equals(it.next())) {
                //list.remove("b");                         //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
                it.remove();
            }
        }*/

        /*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
            if("b".equals(it2.next())) {
                //list.remove("b");                         //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
                it2.remove();
            }
        }*/
        //3,增强for循环,增强for循环不能删除,只能遍历
        for (String string : list) {
            if("b".equals(string)) {
                list.remove("b");
            }
        }
        System.out.println(list);

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

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

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

A:可变参数概述
- 定义方法的时候不知道该定义多少个参数
B:格式
- 修饰符返回值类型方法名(数据类型… 变量名){}
  Int [] arr也可以写出int …arr

public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        //print(arr);
        print(11,22,33,44,55);
        System.out.println("---------------");
        //print();
    }   
    /*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]);
        }
    }

C:注意事项：
- 这里的变量其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

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

A:案例演示
- Arrays工具类的asList()方法的使用
- Collection中toArray(T[] a)泛型版的集合转数组

public static void main(String[] args) {
        //demo1();
        //demo2();
        //集合转数组,加泛型的
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        String[] arr = list.toArray(new String[10]);        //当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size
                                                            //如果数组的长度大于了size,分配的数组长度就和你指定的长度一样
        for (String string : arr) {
            System.out.println(string);
        }
    }

    public static void demo2() {
        //int[] arr = {11,22,33,44,55};         
        //List<int[]> list = Arrays.asList(arr);            基本数据类型的数组转换成集合,会将整个数组当作一个对象转换
        //System.out.println(list);
        Integer[] arr = {11,22,33,44,55};                   //将数组转换成集合,数组必须是引用数据类型
        List<Integer> list = Arrays.asList(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);
    }

19_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)

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

public static void main(String[] args) {
    ArrayList<ArrayList<People>> as=new ArrayList();
    ArrayList<People> a=new ArrayList();
    a.add(new People("张三",32));
    a.add(new People("雏形",32));
    a.add(new People("壮壮",32));
    a.add(new People("盒饭",32));
    ArrayList<People> b=new ArrayList();
    b.add(new People("现在",32));
    b.add(new People("在形",32));
    b.add(new People("进修壮",32));
    b.add(new People("啊啊饭",32));

    as.add(a);
    as.add(b);
    System.out.println(as);

    System.out.println("-----------------");
    for (ArrayList<People> list : as) {
        for (People people : list) {
            System.out.println(people);
        }
    }
}