-
- 1.1 泛型的引入
-
1.2 泛型类的简单演示
-
1.3 泛型的意义
-
1.4 泛型是怎么编译的?
-
1.5 泛型总结
-
2 . 包装类
-
- 2.1 基本数据类型和包装类直接的对应关系
-
2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)
-
3 . ArrayList简介
-
4 . ArrayList使用
-
- 4.1 ArrayList的构造
-
4.2 ArrayList的遍历
-
- 4.2.1 迭代器 Iterator ListIterator
-
4.3 ArrayList常见操作
-
4.4 ArrayList的扩容机制
-
5 . ArrayList的使用示例
-
- 5.1 ArrayList可以放自定义的数据类型
-
5.2 ArrayList可以对数据进行排序
-
5.3 删除第一个字符串当中的第二个字符串中的字符
-
5.4 ArrayList实现的简易扑克牌
-
6 . ArrayList的模拟实现
-
7 . 解决杨辉三角题
=======================================================================
=======================================================================================
问题：我们之前实现过的顺序表，只能保存 int类型的元素，如果现在需要保存 指向 Person类型对象的引用的顺序表，请问应该如何解决？如果又需要保存指向 Book 对象类型的引用呢？
回答：
对象类型的引用呢？
-
首先，我们在学习多态过程中已知一个前提，基类的引用可以指向子类的对象。
-
其次，我们也已知Object是 java 中所有类的祖先类。
那么，要解决上述问题，我们很自然的想到一个解决办法，将我们的顺序表的元素类型定义成 Object类型，这样我们的Object类型的引用可以指向Person类型的对象或者指向Book类型的对象了。
之前的实现的ArrayList:
改成Object之后:
问题:
-
能不能指定这个顺序表的类型?
-
指定类型之后,是不是只能存放指定的数据类型?
-
取出数据,能不能不进行强制类型转换?
于是就有了泛型
// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
class MyArrayList{
private E[] elem;
private int usedSize;
public MyArrayList(){
this.elem = (E[]) new Object[10];
}
public void add(E val){
this.elem[usedSize] = val;
usedSize++;
}
public E get(int pos){
return this.elem[pos];
}
}
public class TestDemo {
public static void main(String[] args) {
MyArrayList myArrayList = new MyArrayList<>();
MyArrayList myArrayList1 = new MyArrayList<>();
MyArrayList myArrayList2 = new MyArrayList<>();
}
}
**1. 自动对类型进行检查
2. 自动对类型进行强制类型的转换
3. 泛型中尖括号当中的内容 不参与类型的组成**
泛型是编译时期的一种机制,擦除机制
**1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。
2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
3. 泛型是一种编译期间的机制，即 MyArrayList 和 MyArrayList 在运行期间是一个类型。
4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>**
==========================================================================
| 基本数据类型 | 包装类 |
| :-: | :-: |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)
-
装箱 装包 : 把简单类型 ========> 包装类类型
-
拆箱 拆包 : 把包装类类型 =========> 简单数据类类型的数据
代码:
public static void main(String[] args) {
Integer a = 123;//装箱 装包[隐式的]
int b = a;//拆箱 拆包[隐式的]
System.out.println(“====================”);
//装箱 装包[显式的]
Integer a2 = Integer.valueOf(123);
Integer a3 = new Integer(123)
//拆箱 拆包[显式的]
int b2 = a2.intValue();
double d = a3.doubleValue();
}
==================================================================================
【说明】
**1.ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问2.ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
3.ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
4.和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
5.ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表**
==================================================================================
| 方法 | 解释 |
| :-- | :-- |
| ArrayList() | 无参构造 |
| ArrayList(Collection<? extends E> c) | 利用其他 Collection 构建 ArrayList |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
有三种遍历方式:for循环,foreach,迭代器
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
arrayList.add(“hello”);
arrayList.add(“+”);
arrayList.add(“world!”);
System.out.println(arrayList);
System.out.println(“1.for循环”);
for (int i = 0; i < arrayList.size(); i++) {
System.out.print(arrayList.get(i)+" ");
}
System.out.println();
System.out.println(“2.foreach”);
for (String s:arrayList) {
System.out.print(s+" ");
}
System.out.println();
System.out.println(“3.使用迭代器的方法”);
Iterator it = arrayList.iterator();
while(it.hasNext()){
System.out.print(it.next()+" ");
}
System.out.println();
System.out.println(“4.迭代器List相关打印”);
ListIterator it2 = arrayList.listIterator();
while (it2.hasNext()){
System.out.print(it2.next()+" ");
}
4.2.1 迭代器 Iterator ListIterator
| 方法 | 解释 |
| :-- | :-- |
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection<? extends E> c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List subList(int fromIndex, int toIndex) | 截取部分 list |
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
System.out.println(“==尾插e=”);
arrayList.add(“a”);
arrayList.add(“b”);
arrayList.add(“c”);
System.out.println(arrayList);
System.out.println(“==将 e 插入到 index 位置=”);
arrayList.add(0,“qwe”);
System.out.println(arrayList);
System.out.println(“==尾插 c 中的元素=”);
ArrayList arrayList1 = new ArrayList<>();
arrayList1.add(“!!!”);
arrayList.addAll(arrayList1);
System.out.println(arrayList);
System.out.println(“==删除 index 位置元素=”);
System.out.println(arrayList.remove(0));
System.out.println(arrayList);
System.out.println(“==删除遇到的第一个 o=”);
System.out.println(arrayList.remove(“a”));
System.out.println(arrayList);
System.out.println(“==获取下标 index 位置元素=”);
System.out.println(arrayList.get(1));
System.out.println(“==将下标 index 位置元素设置为 element=”);
System.out.println(“原来要修改的数据:”+arrayList.set(1,“d”));
System.out.println(arrayList);
System.out.println(“==判断 o 是否在线性表中=”);
System.out.println(arrayList.contains(“!!!”));
System.out.println(“==返回第一个 o 所在下标=”);
System.out.println(arrayList.indexOf(“!!!”));
System.out.println(“==返回最后一个 o 的下标=”);
System.out.println(arrayList.lastIndexOf(“!!!”));
System.out.println(“==截取部分 list=”);
List sub = arrayList.subList(0,2);//左闭右开
System.out.println(sub);
System.out.println(“==情况=”);
arrayList.clear();
System.out.println(arrayList);
}
运行结果:
**结论:
如果ArrayList调用无参的构造方法new ArrayList() , 那么顺序表的大小是0.当第一次add的时候, 整个顺序表才变为了10;
当这10个放满之后,才开始扩容,以1.5倍的方式扩容.
如果调用的是给定容量的构造方法new ArrayList(13) , 那么顺序表的大小就是给定容量的大小,如果放满了,还是以1.5倍进行扩容.**
=====================================================================================
import java.util.ArrayList;
class Student{
private String name;
private String classes;
private double score;
public Student(String name, String classes, double score) {
this.name = name;
this.classes = classes;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClasses() {
return classes;
}
public void setClasses(String classes) {
this.classes = classes;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return “Student{” +
“name='” + name + ‘’’ +
“, classes='” + classes + ‘’’ +
“, score=” + score +
‘}’;
}
}
public class TestDemo10 {
public static void main1(String[] args) {
ArrayList students = new ArrayList<>();
students.add(new Student(“niubi”,“102-1”,98.9));
students.add(new Student(“21e”,“123”,22.2));
students.add(new Student(“qwq”,“wqqe”,455.4));
System.out.println(students);
}
}
运行结果:
public static void main(String[] args) {
ArrayList integers = new ArrayList<>();
integers.add(11);
integers.add(2);
integers.add(13);
Collections.sort(integers);
System.out.println(integers);
}
运行结果:
public static void main(String[] args) {
String str1 = “welcome to bit”;
String str2 = “come”;
ArrayList list1 = new ArrayList<>();
for (int i = 0; i < str1.length(); i++) {
char ch = str1.charAt(i);
if(!str2.contains(ch+“”)){
list1.add(ch);
}
}
for (char ch : list1 ) {
System.out.print(ch);
}
}
运行结果:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
class Card{
private int rank;
private String suit;
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
public int getRank() {
return rank;
}
public void setRank(int rank) {
this.rank = rank;
}
public String getSuit() {
return suit;
}
public void setSuit(String suit) {
this.suit = suit;
}
@Override
public String toString() {
return “{” + suit + “->” +rank + “}”;
}
}
public class Test {
private static final String[] suits = {“❤”,“♠”,“♣”,“♦”};
/**
-
构造一副牌
-
@return
*/
public static List buyCard(){
ArrayList cards = new ArrayList<>();
//四种花色
for (int i = 0; i < 4; i++) {
//每个花色13张牌
for (int j = 0; j < 13; j++) {
/*String suit = suits[i];//花色
int rank = j ;//牌数
Card card = new Card(rank,suit);//得到一张牌card
cards.add(card);*/
cards.add(new Card(j,suits[i]));//优化后的代码
}
}
return cards;
}
private static void swap(List cards,int i,int j){
Card tmp = cards.get(i);
cards.set(i,cards.get(j));
cards.set(j,tmp);
}
/**
-
洗牌
-
@param cards
*/
public static void shuffle(List cards){
int size = cards.size();
for (int i = size - 1; i > 0; i–) {
Random random = new Random();
int rand = random.nextInt(i);
swap(cards,i,rand);
}
}
总结
虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。
架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。
如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。
= new ArrayList<>();
//四种花色
for (int i = 0; i < 4; i++) {
//每个花色13张牌
for (int j = 0; j < 13; j++) {
/*String suit = suits[i];//花色
int rank = j ;//牌数
Card card = new Card(rank,suit);//得到一张牌card
cards.add(card);*/
cards.add(new Card(j,suits[i]));//优化后的代码
}
}
return cards;
}
private static void swap(List cards,int i,int j){
Card tmp = cards.get(i);
cards.set(i,cards.get(j));
cards.set(j,tmp);
}
/**
-
洗牌
-
@param cards
*/
public static void shuffle(List cards){
int size = cards.size();
for (int i = size - 1; i > 0; i–) {
Random random = new Random();
int rand = random.nextInt(i);
swap(cards,i,rand);
}
}
总结
虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。
架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。
如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。
[外链图片转存中…(img-o4X4OSGf-1714721225738)]
4146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
