集合介绍
数组：一旦创建对象，分配内存空间，不可改变空间大小(无法动态扩容)
Collection：可以动态扩容，从而避免数组下标越界。缺点：扩容会消耗你的内存，所以使用集合比使用数组内存开销大。
集合体系结构
ArrayList集合
特征：本质是一个Object [] 数组
可以向集合放入元素，也可以从集合中获取元素，还可以删除集合中的元素
既然是一个数组，放入元素和获取元素(根据下标获取)速度快，删除首部元素和中间元素效率低
为什么要使用泛型？
你可以将任意类型的数据放入ArrayList，取出数据必须强制转换
泛型：能够在编译期对放入和取出的对象(元素)做类型检查
定义泛型：类型不确定，一旦你在某个类上定义了泛型，可以将泛型作为属性、参数、返回值
使用泛型：必须明确数据类型，数据类型必须在<>中定义
什么时候使用ArrayList？
如果你需要频繁创建元素，频繁获取元素，可以使用
优点：创建和查询(获取)元素快
什么时候不能使用ArrayList？
当你频繁创建和频繁删除元素，不要使用ArrayList
缺点：删除首部元素和中间元素效率低
如何创建一个ArrayList类型的对象
使用new的方式创建
package com.whsxt.day5.arraylist;
import java.util.ArrayList;
import java.util.List;
public class TestArrayList1 {
public static void main(String[] args) {
System.out.println("start");
//ArrayList list = new ArrayList();
//ArrayList是一个List
//new ArrayList 是实实在在的对象，在堆内存中创建
// list 在栈内存中：用来操作堆内存中的ArrayList
// list遥控器 new ArrayList()电视机
List list = new ArrayList();
//调用ArrayList的add(e)方法，将对象放入ArrayList
//第一次调用list对象的add(e)方法添加元素，会在ArrayList内部的数组中分配10个空间的元素
list.add("tom1");
list.add("tom2");
list.add("tom3");
list.add("tom4");
list.add("tom5");
list.add("tom6");
list.add("tom7");
list.add("tom8");
list.add("tom9");
list.add("tom10");
//还有新元素添加到ArrayList中，不会出现“数组下标越界异常”
list.add("tom11");
list.add("tom12");
System.out.println("end");
}
}
String str1 = "a" + 1 + 2; // a12
String str2 = 'a' + 1 + "2"; // 982 （a的ASCll码为97）97+1+"2"=982
String str3 = 1 + 2 + "a"; // 3a
小结：
第一次调用list对象的add(e)方法添加元素，会在ArrayList内部的数组中分配10个空间的元素，当数组空间全部使用完毕，还有新元素添加到ArrayList中，不会出现“数组下标越界异常”,此时数组会扩容
ArrayList是一个可以动态扩容的数组
ArrayList扩容(重点)
当我创建ArrayList对象，里面的数组大小0，第一次调用add(E)方法，数组大小为10，当元素全部占满数组大小为10，如果继续添加元素，数组大小15
0---->10---->15--->22
int size =15;
int newCapacity= (size>>1)+size; 1111>>1 111+1111=22
扩容规律：原始长度>>1 + 原始长度
小结：
在调用add(e)方法添加元素之前，先判断数组有没有空间存储新元素，如果有不会扩容，如果没有才扩容
每次扩容ArrayList里面的Object elementData[] 指向都会发生改变
扩容机制：在原始数组的基础上重新拷贝一份新数组，此时新数组会存储原始数组里面的元素
import java.util.ArrayList;
import java.util.List;
public class TestArrayList1 {
public static void main(String[] args) {
System.out.println("start");
//ArrayList list = new ArrayList();
//ArrayList是一个List
//new ArrayList 是实实在在的对象，在堆内存中创建
// list 在栈内存中：用来操作堆内存中的ArrayList
// list遥控器 new ArrayList()电视机
List list = new ArrayList();
//调用ArrayList的add(e)方法，将对象放入ArrayList
//第一次调用list对象的add(e)方法添加元素，会在ArrayList内部的数组中分配10个空间的元素
list.add("tom1");
list.add("tom2");
list.add("tom3");
list.add("tom4");
list.add("tom5");
list.add("tom6");
list.add("tom7");
list.add("tom8");
list.add("tom9");
list.add("tom10");
list.add("tom11");
list.add("tom12");
list.add("tom13");
list.add("tom14");
list.add("tom15");
list.add("tom16");
System.out.println("end");
}
}
ArrayList其它方法
get(int index): 根据下标获取集合中的元素
size()：获取集合实际的大小
remove(int index)：根据下标从集合中删除元素
remove(E)： 根据元素内容从集合中删除元素
contains()： 判断某个元素在集合中是否存在，true存在，false不存在
import java.util.ArrayList;
import java.util.List;
public class TestArrayList2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("Tom");
list.add(123);
list.add(3.14);
list.add('M');
list.add(true);
//获取集合的第一个元素
Object element =list.get(0);
int size =list.size();
System.out.println(element); //5
System.out.println("删除之前 size="+size);
//删除集合中第一个元素
list.remove(0);
int size2=list.size(); //4
System.out.println("删除之后 size="+size2);
//判断Abc是否在集合中存在 结果false Abc在集合中不存在
boolean result =list.contains("Abc");
System.out.println(result);
}
}
以下代码存在的问题：
1、 放入集合的类型在编译器不能确定，可以放入任意类型
2、 由问题已引入问题2：元素类型不专一
3、 获取元素必须使用强制类型转换
4、 强制转换的代码不安全 int obj= (int) list.get(0); 可能会出现运行时类型转换异常ClassCastException
要求：解决该问题
目的：放入集合的元素类型必须要专一，要么全部放String、要么全部放Boolean
能够提供编译器的类型检查，例如我规定了集合中只能放置String，如果你放置了Boolean，会提示编译失败
package com.whsxt.day5.arraylist;
import java.util.ArrayList;
import java.util.List;
public class TestArrayList2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("Tom");
list.add(123);
list.add(3.14);
list.add('M');
list.add(true);
int obj= (int) list.get(0);
System.out.println(obj);
}
}
泛型
SinceJDK1.5，提供编译期检查，解决放入集合元素类型不一致的问题，例如：我定义一个ArrayList集合并且规定了只能放置String，如果你放置其他类型就会编译报错
泛型：
1、定义泛型（数据类型不确定）
2、使用泛型 (必须明确数据类型)
定义泛型语法：
< > 用于定义泛型， 钻石运算符，泛型运算符
public class 类名称<类型>{
}
使用泛型：
import java.util.ArrayList;
import java.util.List;
public class TestArrayList2 {
public static void main(String[] args) {
//创建一个ArrayList对象，支持泛型，规定了ArrayList只能存放String类型的元素(对象)
List<String> list = new ArrayList<>();
list.add("Tom");
//编译错误：不能讲int类型的数据放入ArrayList，因为ArrayList在定义的时候使用了泛型，规定了只能存放String类型
//list.add(123);
//使用泛型好处：获取元素不用强制类型转换
String name = list.get(0);
System.out.println(name);
//编译错误：获取元素也能够提供编译检查，由于泛型规定了只能放置String，那么使用非String类型接收，就会编译错误
//int num = list.get(0);
//小结：定义ArrayList使用泛型,好处能够在add()方法和get()方法提供编译期类型检查
}
}
Java泛型不支持基本类型
import java.util.ArrayList;
import java.util.List;
public class TestArrayList3 {
public static void main(String[] args) {
//泛型：不支持基本类型
//List<double> list = new ArrayList<>();
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(1);
//Java提供了自动装箱和自动拆箱，放入ArrayList的元素是包装类型，取出元素可以用基本类型接受
int num = list.get(0);
System.out.println(num);
System.out.println(list);
}
}
自定义泛型
/**
* @author caojie
* 自己定义一个泛型类
* T: Type 类型
* E: Element 元素
* K: Key 键
* V: Value 值
* Foo<T>：我定义的类型Foo支持泛型
* 可以将泛型用于属性，也可以用于参数，该可以用于返回值
*/
public class Foo<T> {
/**
* 定义一个属性，名称叫做type，它在编译期是一个不确定的类型
*/
private T type;
// 编译错误：泛型属性名称必须跟定义泛型的类型一致<T> private T type;
// private E element;
/**
* T：表示返回类型是一个泛型
* @return
*/
public T getType() {
return type;
}
/**
* T type 表示参数是一个泛型
* @param type
*/
public void setType(T type) {
this.type = type;
}
}
/**
* @author caojie
* 可以定义多个泛型，但是必须使用逗号分隔
* @param <K>
* @param <V>
*/
public class FooTwo<K,V> {
private K key;
private V value;
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
public class FooThree<T> {
private T [] types;
public T [] getTypes() {
return types;
}
public void setTypes(T [] types) {
this.types = types;
}
}
/**
* @author caojie
* 使用定义的泛型
*/
public class TestFoo {
public static void main(String[] args) {
// 不使用泛型，程序编译期不能提供类型检查，运行期就会出现异常
/* Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
at com.whsxt.day5.generic.TestFoo.main(TestFoo.java:14) */
// Foo foo = new Foo();
// foo.setType("Tom");
// int num=(int)foo.getType();
// System.out.println(num);
Foo<String> foo = new Foo<>();
foo.setType("Tomson");
String name = foo.getType();
// 使用泛型能够提供编译期类型检查
// int num = foo.getType();
System.out.println(name);
}
}
import java.util.Arrays;
public class TestFooThree {
public static void main(String[] args) {
FooThree<String> foo =new FooThree<>();
String names[] = {"TOm","Jerry","Jason"};
foo.setTypes(names);
String result[] =foo.getTypes();
System.out.println(Arrays.toString(result));
}
}
public class Test2FooThree {
public static void main(String[] args) {
FooThree<Integer> foo = new FooThree<>();
//int arrs[]= {10,20,30};
//Java虽然能支持自动装箱和自动拆箱，但是无法运用到泛型
//foo.setTypes(arrs);
Integer arrs[]= {110,20,30};
foo.setTypes(arrs);
}
}
使用泛型自定义一个ArrayList
import java.util.Arrays;
/**
* @author caojie
* 自定义的ArrayList，支持泛型
*/
public class ArrayList<E> {
/**
* ArrayList核心是一个数组
*/
private Object elementData [];
/**
* ArrayList大小
*/
private int size;
public ArrayList() {
//调用带参数的构造方法
this(10);
}
/**
* 带有一个参数的构造方法
* @param capacity 初始容量
*/
public ArrayList(int capacity) {
elementData = new Object[capacity];
}
/**
* 返回集合的大小(实际容量，不是数组长度)
* @return 集合大小
*/
public int size() {
return size;
}
/**
* 根据下标获取集合的元素
* @param index 外界传入的下标
* @return 返回集合的元素
*/
@SuppressWarnings("unchecked")
public E get(int index) {
//条件成立：下标是非法的，无法获取数组元素,抛出数组下标越界异常
if(index<0 || index>=size) {
throw new ArrayIndexOutOfBoundsException("size:"+size+" index:"+index);
}
return (E) elementData[index];
}
// 定义扩容次数
private int index = 0;
public void add(E element) {
// 新元素加入到ArrayList中，先检查容量，如果容量不够了，需要扩容
int length = elementData.length;
// 条件成立：表示elementData数组容量已经满了，需要扩容
if(size>=length) {
//新容量= (旧数组长度>>1)+旧数组长度
int newCapacity = (length>>1)+length;
elementData =Arrays.copyOf(elementData,newCapacity);
index++;
System.out.println("扩容"+index+"次");
}
//新加入的元素填充到数组中
elementData[size++]= element;
}
}
测试泛型
package com.whsxt.day5.generic;
public class TestArrayList {
public static void main(String[] args) {
/*
* 使用无参构造方法创建ArrayList对象扩容太频繁(23次）
* 不要频繁扩容，也不要永远不扩容（性能消耗大）
* 理想方案：扩容次数15次以内
* 注意：每当你定义ArrayList的时候，思考一个问题，我的ArrayList大概需要容纳多少元素，调用对应的有参数构造方法
* */
ArrayList<Integer> list = new ArrayList<>(2000);
for(int i=0;i<100000;i++) {
list.add(i+10);
}
System.out.println(list.size());
}
}