Java基础——容器（Collection接口、List接口、ArrayList、LinkedList、set接口、HashSet、TreeSet）

一.容器
1.数组和容器.
数组就是一种容器,可以在其中放置对象或基本类型数据。

数组特点:
1.定长
2.数据类型相同
3.有序数组:存储多个数据

容器类:存储多个数据

2.自定义容器

import java.util.Arrays;

//自定义容器类
public class App {
public static void main(String[] args) {
MyContainer my=new MyContainer();
my.add("春");
my.add("夏");
my.add("秋");
my.add("冬");
System.out.println(my.size());//4
//根据索引进行获取数据
System.out.println(my.get(0));//春
System.out.println(my.get(1));春
System.out.println(my);//MyContainer [arr=[春, 夏, 秋, 冬], size=4]

//根据索引删除
my.remove(0);
System.out.println(my);//MyContainer [arr=[夏, 秋, 冬], size=3]

}
}

class MyContainer{
//内存真实存储数据的数组
private String[] arr;
//容器中数据的个数
private int size;

public MyContainer() {
arr=new String[0];
}

/*
*删除数据 remove(index)->索引
*	返回被删除的数据
*/
public String remove(int index) {
//备份原数组
String[] temp=arr;
//创建新数组
arr=new String[size-1];
//遍历拷贝
for(int i=0;i<size;i++){
if(i>index){
arr[i-1]=temp[i];
}else if(i<index){
arr[i]=temp[i];
}else{
continue;
}
}
size--;
return temp[index];
}
/*
* 获取方法   参数是索引  返回值是索引对应的数据
*/
public String get(int index) {
if(index<0 || index>size){
throw new  ArrayIndexOutOfBoundsException(index+"越界了!!!");
}
return arr[index];
}

/*
* 添加方法 add(String)
*/
public void add(String value) {
//备份原数组
String[] temp=arr;
//1.先给数组扩容
arr=new String[size+1];  //arr指向新数组
//2.把value赋值到新数组中
arr[size]=value;
//3.原数组中数据进行拷贝
for(int i=0;i<size;i++){
arr[i]=temp[i];
}
//4.长度改变+1
size++;
}

public int size(){
return size;
}

@Override
public String toString() {
return "MyContainer [arr=" + Arrays.toString(arr) + ", size=" + size + "]";
}

}

3.Collection 容器的父接口
一些 collection 允许有重复的元素，而另一些则不允许。
Set子接口:无序的不可重复
List子接口:有序的可重复

容器可以存储任意类型的数据
只能存储引用数据类型的数据,自动装箱

常用方法

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionDemo01 {
public static void main(String[] args) {
//创建容器类对象
Collection collection=new ArrayList<>();
Collection collection2=new ArrayList<>();
Collection collection3=new ArrayList<>();
//添加指定元素 add()
collection.add("Lebron");
collection.add("Wade");
collection.add(23);
collection.add(true);
collection.add("Wade");
System.out.println(collection);

collection2.add("Curry");
collection2.add("KD");
//addAll(Collection)
collection.addAll(collection2);
System.out.println(collection);

collection3.add(23);
collection3.add("Wade");

/*
*  void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o )  判断是否包含
boolean isEmpty()
*/
//collection2.clear();
//System.out.println(collection2);
//System.out.println("isEmpty:"+collection2.isEmpty());
System.out.println(collection.containsAll(collection2));

/*
*  boolean remove(Object o)
*  boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)   求交集
*/
collection.remove("Wade");//移出索引靠前的内容
System.out.println(collection);
collection.removeAll(collection2);
System.out.println(collection);

System.out.println(collection.retainAll(collection3));;
System.out.println(collection);

/*
* int size()
返回此 collection 中的元素数。
Object[] toArray()
*/
System.out.println(collection.size());
System.out.println(Arrays.toString(collection.toArray()));
}
}

遍历
增强for|for…each

迭代器
1.获取迭代某一个容器的迭代器对象
2.判断是否存在下一个可迭代的元素 hasNext() ->true,false
3.返回下一个元素 next() ->下一个元素

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

//collection
public class CollectionDemo02 {
public static void main(String[] args) {
//泛型  提高稳定性和可读性  规定容器中所有数据的数据类型
Collection<String> collection=new ArrayList<>();
collection.add("wade");
collection.add("james");
collection.add("bosh");

//增强for|for..each
for(String s:collection){
System.out.println("字符串:"+s+" 字符串长度:"+s.length());
}

//迭代器
/*
* 1.获取迭代某一个容器的迭代器对象
* 2.判断是否存在下一个可迭代的元素  hasNext()  ->true,false
* 3.返回下一个元素 next() ->下一个元素
*/
Iterator<String> iterator=collection.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}

4.List接口
特点
有序可重复,有索引
新增了一些根据索引操作的方法
方法

public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(111);
list.add(222);

//根据索引插入 add
list.add(1, 666);//原位置的数据后移
System.out.println(list);//[111, 666, 222]

//E get(int index)     返回列表中指定位置的元素。
System.out.println(list.get(0));//111

// int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
System.out.println(list.indexOf(222));//2

//E set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
list.set(0, 1);
System.out.println(list);//[1, 666, 222]

//E remove(int index) 移除列表中指定位置的元素（可选操作）。
System.out.println(list.remove(1));  //666 以索引为主

//List<E> subList(int fromIndex, int toIndex) toIndex 不包含
System.out.println(list);//[1, 222]
System.out.println(list.subList(0,1));//[1]
}

遍历
1.普通for
2.for…each
3.iterator

public static void main(String[] args) {
List<Double> list=new ArrayList<Double>();
list.add(1.1);
list.add(2.2);
list.add(3.3);

//1.普通for
for(int i=0;i<=list.size()-1;i++){
System.out.println(list.get(i));
}

//2.for..each
for(Double d:list){
System.out.println(d);
}

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

练习
List集合,集合中存储NBA人物,如果有詹姆斯,就添加一个韦德
ListIterator listIterator() 返回此列表元素的列表迭代器（按适当顺序）

public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("詹姆斯");
list.add("欧文");
list.add("乐福");

//1.普通for
for(int i=0;i<list.size();i++){
if("詹姆斯".equals(list.get(i))){
list.add("韦德");
}
}
System.out.println(list);

//2.for..each
//ConcurrentModificationException 当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
/*for(String d:list){
if("詹姆斯".equals(d)){  //避免空指针异常
list.add("韦德");
}
}
System.out.println(list);*/

//3.iterator
//java.util.ConcurrentModificationException
/*for(Iterator<String> iterator=list.iterator();iterator.hasNext();){
if("詹姆斯".equals(iterator.next())){
list.add("韦德");
}
}
System.out.println(list);*/

//4.ListIterator<E> listIterator()   返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<String> iterator=list.listIterator();
while(iterator.hasNext()){
if("詹姆斯".equals(iterator.next())){//值写在前面 避免空指针异常
iterator.add("韦德");
}
}
System.out.println(list);
}

5.ArrayList(最重要的容器类之一)
List接口的实现类:有序可重复

ArrayList:
底层: 数组(可变数组),数组再内存中是连续的内存空间
优点: 查询,随机访问效率高
缺点: 增删效率低(改变容量涉及到数组的拷贝)
动态扩容:通过调用Arrays.copyOf()方法进行动态扩容,扩容后新容器的大 小是原容量的1.5倍
第一次添加数据初始容量为10,加载因子(0~1):1
新增方法:使用List定义的方法
线程不安全的容器类

Vector 向量
底层实现和特点与ArrayList类似
1)Vector线层安全的容器类|同步的,效率较低
2)扩容原容量的2倍

import java.util.ArrayList;

// 最重要的容器类之一ArrayList
public class ArrayListDemo04 {
public static void main(String[] args) {
ArrayList<Person> list=new ArrayList();
Person person=new Person("詹姆斯",23);
list.add(person);
list.add(new Person("韦德",3));
//1  重写equals方法比较Person对象的内容,否则比较两个对象的地址
System.out.println(list.indexOf(new Person("韦德",3)));
System.out.println(list);
}
}
class Person{
private String name;
private int num;

public Person() {
// TODO Auto-generated constructor stub
}

public Person(String name, int num) {
super();
this.name = name;
this.num = num;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getNum() {
return num;
}

public void setNum(int num) {
this.num = num;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (num != other.num)
return false;
return true;
}

@Override
public String toString() {
return "Person [name=" + name + ", num=" + num + "]";
}
}

6.LinkedList
底层:双向链表实现
优点:增删效率高
缺点:查询或随机获取效率低
新增方法:新增了一些操作与链表头和链表尾的功能(见名知意的方法使用)
7.set接口
无序的不可重复的,null值只能存在一个
没有新增方法,与Collection中功能相同

遍历: 1.增强for 2.迭代器
8.HashSet
底层是有HashMap维护的
底层:由哈希表结构存储(数组+链表+红黑树)
优点:查询,增加,删除效率较高
缺点:无序
扩容:默认初始容量16,加载因子0.75 ,扩容是原容量的2倍

HashSet存储引用数据类型去重:需要重写hashCode()方法和equals()方法进行自定义类型去重
如果不重写hashCode(),可以遇到没有equals方法这一步就已过滤掉不是相同的对象了,直接存储,不会equals方法比较
hashCode()相同的对象有可能相同可以不相同,进一步比较equals()
hashCode()不相同的对象肯定不相同,过滤掉一写不相同的对象,不需要进一步比较equals方法效率较高

9.TreeSet
底层是由TreeMap维护的
底层:红黑树结构实现
优点:默认升序排序(默认自然排序|指定排序)
缺点:么有HashSet效率高

存储引用数据类型的时候(引用数据类型对象的排序,引用数据类型对象的去重):引用数据类型1)实现内部比较器 2)自定义外部比较器

Comparable接口->内部比较器|自然排序,重写compareTo()方法,方法中自定义比较规则
Comparator接口->外部比较器|自定义比较器|自定义排序:重写compare()方法,方法中自定义比较规则