java-List

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

java-List

大家好我是晓星航。今天为大家带来的是 java数据结构中List知识的讲解😀

1. 预备知识-泛型(Generic)

1.1 泛型的引入

**问题**我们之前实现过的顺序表只能保存 int 类型的元素如果现在需要保存 指向 Person 类型对象的引用的顺序表请问应该如何解决如果又需要保存指向 Book 对象类型的引用呢

回答

  1. 首先我们在学习多态过程中已知一个前提基类的引用可以指向子类的对象。
  2. 其次我们也已知 Object 是 java 中所有类的祖先类。

那么要解决上述问题我们很自然的想到一个解决办法将我们的顺序表的元素类型定义成 Object 类型这样我们的 Object 类型的引用可以指向 Person 类型的对象或者指向 Book 类型的对象了。

示例代码

public class MyArrayList {
        private Object[] array; // 保存顺序表的元素即 Object 类型的引用
        private int size; // 保存顺序表内数据个数
        public void add(Object o) { 尾插 }
        public Object get(int index) {
         获取 index 位置的元素 
         }
        ...
}

这样我们可以就可以很自由的存储指向任意类型对象的引用到我们的顺序表了。

示例代码

MyArrayList books = new MyArrayList();
for (int i = 0; i < 10; i++) {
    books.add(new Book()); // 尾插 10 本书到顺序表
}
MyArrayList people = new MyArrayList();
for (int i = 0; i < 10; i++) {
    people.add(new Person()); // 尾插 10 个人到顺序表
}

遗留问题现在的 MyArrayList 虽然可以做到添加任意类型的引用到其中了但遇到以下代码就会产生问题。

MyArrayList books = new MyArrayList();
books.add(new Book);
// 将 Object 类型转换为 Person 类型需要类型转换才能成功
// 这里编译正确但运行时会抛出异常 ClassCastException
Person person = (Person)books.get(0);

提示问题暴露的越早影响越小。编译期间的问题只会让开发者感觉到运行期间的错误会让所有的软件使用者承受错误风险。

所以我们需要一种机制可以 1. 增加编译期间的类型检查 2. 取消类型转换的使用 泛型就此诞生

泛型的意义

  1. 自动对类型进行检查
  2. 自动对类型进行强制类型的转换

1.2 泛型的分类

  1. 泛型类
  2. 泛型方法

1.3 泛型类的定义的简单演示

关于泛型类的定义这里只是了解即可我们重点学习泛型类的使用。

// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)变量名一般要大写
// 3. E 在定义时是形参代表的意思是 MyArrayList 最终传入的类型但现在还不知道
        public class MyArrayList<E> {
            private E[] array;
            private int size;
            ...
        }

注意 泛型类可以一次有多个类型变量用逗号分割。

1.4 泛型背后作用时期和背后的简单原理

  1. 泛型是作用在编译期间的一种机制即运行期间没有泛型的概念。
  2. 泛型代码在运行期间就是我们上面提到的利用 Object 达到的效果这里不是很准确以后会做说明。

1.5 泛型类的使用

// 定义了一个元素是 Book 引用的 MyArrayList
MyArrayList<Book> books = new MyArrayList<Book>();
books.add(new Book());
        
// 会产生编译错误Person 类型无法转换为 Book 类型
books.add(new Person());

// 不需要做类型转换
Book book = book.get(0);

// 不需要做类型转换
// 会产生编译错误Book 类型无法转换为 Person 类型
Person person = book.get(0);

通过以上代码我们可以看到泛型类的一个使用方式只需要在所有类型后边跟尖括号并且尖括号内是真正的类型即 E 可以看作的最后的类型。

注意 Book 只能想象成 E 的类型但实际上 E 的类型还是 Object。

1.6 泛型总结

  1. 泛型是为了解决某些容器、算法等代码的通用性而引入并且能在编译期间做类型检查。
  2. 泛型利用的是 Object 是所有类的祖先类并且父类的引用可以指向子类对象的特定而工作。
  3. 泛型是一种编译期间的机制即 MyArrayList 和 MyArrayList

在运行期间是一个类型

  1. 泛型是 java 中的一种合法语法标志就是尖括号 <>

2. 预备知识-包装类(Wrapper Class)

Object 引用可以指向任意类型的对象但有例外出现了8 种基本数据类型不是对象那岂不是刚才的泛型机制要失效了

实际上也确实如此为了解决这个问题java 引入了一类特殊的类即这 8 种基本数据类型的包装类在使用过程中会将类似 int 这样的值包装到一个对象中去。

2.1 基本数据类型和包装类直接的对应关系

基本就是类型的首字母大写除了 Integer 和 Character。

例如我们将String(字符串)转为int(整形)类型

String str = "123";
int ret = Integer.valueOf(str);
System.out.println(ret + 1);

2.2 包装类的使用装箱(boxing)和拆箱(unboxing)

装箱、装包把简单类型–>包装类类型

拆箱、拆包把包装类类型–>简单数据类型

int i = 10;

// 装箱操作新建一个 Integer 类型对象将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);

// 拆箱操作将 Integer 对象中的值取出放到一个基本数据类型中
int j = ii.intValue();

2.3 自动装箱(autoboxing)和自动拆箱(autounboxing)

可以看到在使用过程中装箱和拆箱带来不少的代码量所以为了减少开发者的负担java 提供了自动机制。

int i = 10;

Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱

int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

注意自动装箱和自动拆箱是工作在编译期间的一种机制。

小问题-为什么Interger类型的a与b赋值为129时结果是false但是a与b赋值为123时结果是true?

底层方法代码

答因为Integer value0f中如果范围在-128——127时就调用high方法运行结果就是true。如果范围不在-128——127时那么就会调用catch中的low方法结果就为false

2.4 javap 反编译工具

这里我们刚好学习一个 jdk 中一个反编译工具来查看下自动装箱和自动拆箱过程并且看到这个过程是发生在编译期间的。

javap -c类名称
  Compiled from "Main.java"
  public class Main {
    public Main();
      Code:
       0: aload_0
       1: invokespecial #1 // Method java/lang/Object."<init>":()V
       4: return
       
     public static void main(java.lang.String[]);
       Code:
       0: bipush 10
       2: istore_1
       3: iload_1
       4: invokestatic #2 // Method java/lang/Integer.valueOf:
(I)Ljava/lang/Integer;
       7: astore_2
       8: iload_1
       9: invokestatic #2 // Method java/lang/Integer.valueOf:
(I)Ljava/lang/Integer;
       12: astore_3
       13: aload_2
       14: invokevirtual #3 // Method java/lang/Integer.intValue:()I
       17: istore 4
       19: aload_2
       20: invokevirtual #3 // Method java/lang/Integer.intValue:()I
       23: istore 5
       25: return
}

3. List 的使用

List的官方文档

ArrayList的官方文档

LinkedList的官方文档

3.1 常见方法

List线性表

上述图片方法举例可以参考下方超链接中的String中6.1–6.6的方法举例。

String方法博客

subList方法演示

ArrayList<String> list = new ArrayList<>();
list.add("hello");
list.add("xxh");
list.add("xyh");
list.add("lol");
list.add("coc");
System.out.println(list.subList(1, 3));
System.out.println(list);

这里subList截取了三个元素但是只输出了两个元素是因为我们在使用list的方法中采取的是左闭右开的模式。

ArrayList顺序表

如果ArrayList调用不带参数的构造方法那么顺序表的大小是0.当第一次add的时候整个顺序表才变为了10当这10个放满了开始扩容以1.5倍的方式进行扩容。

如果调用的是给定容量的构造方法那么你的顺序表大小就是你给定的容量放满了还是1.5倍扩充。

此时ArrayList链表的初始大小即为13。

LinkedList链表

3.2 示例

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

public class TestDemo {
    public static void main(String[] args) {
        List<String> courses = new ArrayList<>();
        courses.add("C 语言");
        courses.add("Java SE");
        courses.add("Java Web");
        courses.add("Java EE");
// 和数组一样允许添加重复元素
        courses.add("C 语言");
// 按照添加顺序打印
        System.out.println(courses);
// 类似数组下标的方式访问
        System.out.println(courses.get(0));
        System.out.println(courses);
        courses.set(0, "计算机基础");
        System.out.println(courses);
// 截取部分 [1, 3)
        List<String> subCourses = courses.subList(1, 3);
        System.out.println(subCourses);
// 重新构造
        List<String> courses2 = new ArrayList<>(courses);
        System.out.println(courses2);
        List<String> courses3 = new LinkedList<>(courses);
        System.out.println(courses3);
// 引用的转换
        ArrayList<String> courses4 = (ArrayList<String>)courses2;
        System.out.println(courses4);
// LinkedList<String> c = (LinkedList<String>)course2; 错误的类型
        LinkedList<String> courses5 = (LinkedList<String>)courses3;
        System.out.println(courses5);
// ArrayList<String> c = (ArrayList<String>)course3; 错误的类型
    }
}

运行结果

3.3 练习-扑克牌

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

public class TestDemo {
    public class Card {
        public int rank; // 牌面值
        public String suit; // 花色
        @Override
        public String toString() {
            return String.format("[%s %d]", suit, rank);
        }
    }
    public class CardDemo {
        public static final String[] SUITS = {"♠", "♥", "♣", "♦"};
        // 买一副牌
        private static List<Card> buyDeck() {
            List<Card> deck = new ArrayList<>(52);
            for (int i = 0; i < 4; i++) {
                for (int j = 1; j <= 13; j++) {
                    String suit = SUITS[i];
                    int rank = j;
                    Card card = new Card();
                    card.rank = rank;
                    card.suit = suit;
                    deck.add(card);
                }
            }
            return deck;
        }
        private static void swap(List<Card> deck, int i, int j) {
            Card t = deck.get(i);
            deck.set(i, deck.get(j));
            deck.set(j, t);
        }
        private static void shuffle(List<Card> deck) {
            Random random = new Random(20190905);
            for (int i = deck.size() - 1; i > 0; i--) {
                int r = random.nextInt(i);
                swap(deck, i, r);
            }
        }

        public static void main(String[] args) {
            List<Card> deck = buyDeck();
            System.out.println("刚买回来的牌:");
            System.out.println(deck);
            shuffle(deck);
            System.out.println("洗过的牌:");
            System.out.println(deck);
// 三个人每个人轮流抓 5 张牌
            List<List<Card>> hands = new ArrayList<>();
            hands.add(new ArrayList<>());
            hands.add(new ArrayList<>());
            hands.add(new ArrayList<>());
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 3; j++) {
                    hands.get(j).add(deck.remove(0));
                }
            }
            System.out.println("剩余的牌:");
            System.out.println(deck);
            System.out.println("A 手中的牌:");
            System.out.println(hands.get(0));
            System.out.println("B 手中的牌:");
            System.out.println(hands.get(1));
            System.out.println("C 手中的牌:");
            System.out.println(hands.get(2));
        }
    }

运行结果

3.4 面试题练习

杨辉三角

感谢各位读者的阅读本文章有任何错误都可以在评论区发表你们的意见我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞你的每一次鼓励都是作者创作的动力哦😘

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: Java
返回列表

上一篇：chatgpt小程序版本来了，解决你们手机上想用用不了的问题，chatgpt接口用到小程序里面，调用openai接口，提供前后端源码，可以私有部署使用

下一篇：【数据结构和算法】实现线性表中的静态、动态顺序表

“java-List” 的相关文章

Java IO流 - 字节流的使用详细介绍_java字节流的使用1年前 (2023-02-02)
基于Java swing+mysql+eclipse的【图书管理系统】_eclipse图书管理系统1年前 (2023-02-02)
Java 编程要点之 I/O 流详解1年前 (2023-02-02)
【尚硅谷】Java数据结构与算法笔记09 - 哈希表1年前 (2023-02-02)
Java学习（82）Java集合——集合概述、集合框架的体系结构1年前 (2023-02-02)
【Java数据结构及算法实战】系列002：算法的四种描述方式1年前 (2023-02-02)
记录一个Java三元表达式中的陷阱1年前 (2023-02-02)
【Java多线程】线程的常用方法1年前 (2023-02-02)
LeetCode Top Interview Questions 328. Odd Even Linked List (Java版; Medium)1年前 (2023-02-02)
LeetCode Top Interview Questions 7. Reverse Integer (Java版; Easy)1年前 (2023-02-02)

阿里云国际版