在开发实践中，对于数据的处理十分重要，而经常面对方方面面的数据是常态，所需要的数据形式、保存数据，变换数据长度、更改数据类型，就需要数据结构来实现，需要一些能够动态增长长度的容器来保存我们的数据。Java中对于各种数据结构的实现，就是我们用到的集合。
在集合中还会使用到泛型这一方式，利于数据的处理，传输改变。
泛型早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。面对类型转换，而泛型就是最好的解决方法。
泛型是参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的
变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。
通过泛型可以完成对一组类的操作对外开放相同的接口。
Demo genericInteger = new Demo();
从泛型类派生子类当子类为泛型时，子类父类泛型类型一致
class A extends Demo
子类非泛型而有固定类型是，父类也需要明确类型
class A extends Demo
泛型接口public interface Demo { //定义一个泛型接口
public T next();
}
Set接口继承了Collection接口，有两个实现类。
HashSet
HashSet类中的元素不能重复，底层数据结构是哈希表+链表。无索引
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
public static void main(String[] args) {
HashSet set = new HashSet<>();
set.add("a");
set.add("b");
set.add("c");
set.add("w");
set.add("s");
set.add("a");
//set.clear();
Iterator it = set.iterator();
while(it.hasNext()){
//String item=it.next();
System.out.println(it.next());
}
}
}
TreeSet
可以给Set集合中的元素进行指定方式的排序，底层数据结构是二叉树。
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet tset = new TreeSet<>();
tset.add(2);
tset.add(1);
tset.add(3);
tset.add(4);
tset.add(4);
System.out.println(tset);
}
}
● List 中的数据对象有顺序且可以重复。
List继承了Collection接口,有三个实现的类
－ ArrayList查询快，中间删除、添加慢
数组列表，数据采用数组方式存储，ArrayList实现了长度可变的数组。
import java.util.ArrayList;
public class ArrayListDeom {
public static void main(String[] args) {
ArrayList alist = new ArrayList(); //创建对象时不会创建数组,第一次添加时创建容量为10的数组
ArrayList alist2 = new ArrayList(20);//创建对象时,创建一个指定容量的数组
//add(E e) 向末尾添加元素进来
alist.add("a");
alist.add("c");
alist.add("g");
alist.add(4, "F");//在索引位置添加字符F
System.out.println(alist.get(2));//获得索引为2的字符
System.out.println(alist.indexOf("a"));//获取内容为a的字符首次出现的索引
System.out.println(alist.remove(3));//删除索引位置3的字符
System.out.println(alist.remove("a"));//删除内容为a的字符
alist.set(2,"H");//把索引为2的字符替换成H
System.out.println(alist.size());//获得数组大小
System.out.println(alist);//打印数组
}
}
－LinkedList查询慢 ，中间删除添加快
链表，采用链表存储方式
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList llist = new LinkedList<>();
llist.add("a");
}
}
－Vector数组列表，线程安全
数组列表，添加同步锁,线程安全的
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector<>();
v.add("a");
v.add("a");
}
}
Map接口
双列存储 键–值，键不允许重复,值可以重复 。
Map接口常用方法
V put(K key,V value)//存入键–值
V remove(Object key)//删除指定的键,返回对应的值
void clear()//清空键–值
boolean containsKey(Object key)//判断是否包含指定的键
boolean containsValue(Object value)//判断是否包含指定的值
boolean isEmpty()//判断是否为空
int size()//判断大小
V get(Object key)根据指定的键找到对应的值
Collection values()//返回map中包含值的collection视图
Set keySet()//获取map中键的那一列,存放到一个set中
Set> entrySet()//返回map中包含映射的Set视图
● HashMap
HashMap中元素的key值不能重复， 排列顺序是不固定的,可以存储一个为null的键。
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
Map map = new HashMap();
map.put("a", "aa");
map.put("s", "ss");
map.put("w", "ww");
map.put("b", "bb");
map.put("通话", "bb");
map.put("重地", "bb");
map.put("z", "zz");
map.put("a", "aaa");
System.out.println(map.containsKey("a"));
System.out.println(map.containsValue("zz"));
System.out.println(map.get("ww"));
System.out.println(map.remove("s"));
System.out.println(map.size());
System.out.println(map);
Set set = map.keySet();
System.out.println(set);
Collection list = map.values();
System.out.println(list);
Set> entrySet = map.entrySet();
for(Entry entry : entrySet){
System.out.println(entry.getKey()+"::"+entry.getValue());
}
}
}
● TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序
的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
import java.util.Hashtable;
import java.util.TreeMap;
import java.util.TreeSet;
public class HashtableDemo {
public static void main(String[] args) {
TreeMap tmap = new TreeMap<>();
tmap.put("b", "b");
tmap.put("a", "a");
tmap.put("c", "c");
tmap.put("d", "d");
System.out.println(tmap);
}
}
● HashTable
实现了同步。
不能存储为null的键
import java.util.TreeMap;
import java.util.TreeSet;
public class HashTreeDemo {
public static void main(String[] args) {
Hashtable map = new Hashtable();
map.put("a", "aa");
map.put("a", "bb");
//map.put(null, "aa");//不允许为nullkey
map.put("c", "aa");
}
}
Collections类
addAl l(Col lection c, T… elements);//插入数据
binarySearch(List> l ist, T key)
sort(List l ist)//排序
sort(List l ist, Comparator c)//按照给定方式排序
swap(List l ist, int i, int j)//
copy(List dest, List src) ; //复制，注意 dest size需大于等于src.size
emptyList() 返回为空的集合,不能添加数据
fi l l(List l ist, T obj)
max(Col lection col l)//最大
min(Col lection col l)//最小
replaceAl l(List l ist, T oldVal, T newVal)//分割
reverse(List l ist)
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsDemo {
public static void main(String[] args) {
//System.out.println(Collections.binarySearch(list,4));
//Collections.swap(list, 0, 3);
List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(2);
list.add(4);
List list1 = new ArrayList<>();
list1.add(5);
list1.add(6);
list1.add(7);
Collections.copy(list, list1); //把list1的元素复制到list
System.out.println(list);
Collections.fill(list, 5);//用值5填充list，替换其中所有的元素
System.out.println(list);
Collections.replaceAll(list, 2,6);//把表list中2替换为6
System.out.println(list);
Collections.reverse(list);//逆序list
System.out.println(list);
}
}
