java集合框架
图片网上一大堆。
Collection接口
- List接口
ArrayList、LinkedList、Vector、Stack - Set接口
HashSet、LinkedHashSet、TreeSet
Map接口
- HashMap、Hashtable、LinkedHashMap、TreeMap
Collection（因为确定大小的数组不能满足动态改变内存分配大小的问题，所以有集合）
Collection
boolean add(E e) //向集合中添加一个元素，若添加元素后集合发生了变化就返回true，若没有发生变化，就返回false。
boolean addAll(Collection<? extends E> c) //添加给定集合c中的所有元素到该集合中
void clear() //(optional operation).
boolean contains(Object o) //判断该集合中是否包含指定对象
boolean containsAll(Collection<?> c)
boolean equals(Object o)
int hashCode()
boolean isEmpty()//size==0?
Iterator<E> iterator()
boolean remove(Object o) //移除给定对象的一个实例（有的具体集合类型允许重复元素）
boolean removeAll(Collection<?> c) //移除元素集合c
boolean retainAll(Collection<?> c) //仅保留给定集合c中的元素
int size()
Object[] toArray()
<T> T[] toArray(T[] a)
代码列举
public class Demo {
public static void main(String[] args) {
Collection datas = new LinkedList();//可以不像数组那样指定大小
datas.add("aaa");//添加元素
System.out.println(datas.add("bbb"));//true
if (!datas.contains("ccc")) {
datas.add("ccc");
}
///////////////////////////////////////////
Collection datas1 = new ArrayList();
datas1.add("aaa");
datas1.add("bbb");
//判断子集合中的所有对象是否存在
if (datas.containsAll(datas1)) {//true
System.out.println("datas包含datas1");//输出
}
Collection datas3 = new ArrayList(10);
datas3.add("eee");
datas3.add("fff");
datas3.add("ggg");
datas.addAll(datas3);
//////////////////////////////////////////
System.out.println(datas);//[aaa, bbb, ccc, eee, fff, ggg]
System.out.println(datas.size());//6
datas.remove("ccc");
datas.retainAll(datas3);
System.out.println(datas);//[eee, fff, ggg]
datas.clear();
System.out.println(datas.size());//0
Iterator iterator = datas1.iterator();//迭代器
while (iterator.hasNext()) {
System.out.println(iterator.next());//输出datas1中所有元素
}
}
}
List(存储对象有序，可以包含重复元素)
-
方法相比Collection多了如下:
E get(int var1);//返回指定下标的元素 E set(int var1, E var2);//修改指定下标的值 void add(int var1, E var2);//在指定位置添加元素 int indexOf(Object var1);//返回指定元素的下标 int lastIndexOf(Object var1);//返回指定元素的最后一个的下标 ListIterator<E> listIterator();//迭代器 List<E> subList(int var1, int var2);//链表截取
代码例举:
/**
* List
*/
public class Demo {
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.add("ddd");
list1.add("eee");
list1.add("fff");
list1.add("ggg");
System.out.println(list1.get(4));//eee
System.out.println(list1);//[aaa, bbb, ccc, ddd, eee, fff, ggg]
list1.set(2, "eee");
list1.add(3, "zzz");//指定位置添加元素
System.out.println(list1);//[aaa, bbb, eee, zzz, ddd, eee, fff, ggg]
System.out.println(list1.indexOf("eee"));//2
System.out.println(list1.lastIndexOf("eee"));//5
System.out.println(list1.subList(2, 4));//返回[2,4)左右开的元素//[eee, zzz]
}
}
ArrayList（底层数组实现（查询快，增删慢））
当容量不够的时候添加的容量是当前的1.5倍
Vector基本用法和ArrayList一样，区别是线程安全（基本不用）
-
底层数组实现（查询快，增删慢）
/** * ArrayList 基本用法同上 */ public class Demo { public static void main(String[] args) { ArrayList<String> list1 = new ArrayList<String>(); list1.add("aaa"); list1.add("bbb"); list1.add("ccc"); list1.add("ddd"); list1.add("eee"); list1.add("fff"); list1.add("ggg"); //错误写法 /* for (String s : list1) { list1.remove(s);//Exception in thread "main" java.util.ConcurrentModificationException }*/ Iterator<String> iterator = list1.iterator(); //错误写法 /* while (iterator.hasNext()) { iterator.remove();//Exception in thread "main" java.lang.IllegalStateException }*/ //正确写法 while (iterator.hasNext()) { iterator.next(); iterator.remove(); } System.out.println(list1); } }
LinkedList（用链表实现（增删快，查询慢））
void addFirst(E element);
void addLast(E element);
E getFirst();
E getLast();
E removeFirst();
E removeLast();
boolean add(E e) //把元素e添加到链表末尾
void add(int index, E element) //在指定索引处添加元素
都可以从字面上了解它的方法含义。
- 用链表实现（增删快，查询慢）
LinkedList源码剖析
Set(存储元素无序，不能有重复元素)
HashSet
/**
* Set
* 存储对象无序，并且唯一
* 如何判断对象的唯一性：根据Object提供的 int hashCode()和boolean equals(Object obj)方法
* 唯一性的过程： 先调用对象的hashCode()方法，如果哈希值不相同，则直接添加到集合中，
* 若哈希值相同，则会调用eqauls()方法判断内容是否相同，若返回false，则表示内容不同，
* 那么将其添加到集合中，反之，返回true时，则不添加到集合中
*/
public class Demo {
public static void main(String[] args) {
Set set = new HashSet();
set.add("aaa");//添加的时候就判断唯一性
set.add("bbb");
set.add("ccc");
set.add("aaa");
set.add("ddd");
set.add("aacca");
set.add("aaa");
System.out.println(set);//[aaa, ccc, bbb, ddd, aacca]
Boolean b = false;
//注：hashCode()相同时，并不一定代表是同一类型的对象
System.out.println(b.hashCode() + "," + new Integer(1237).hashCode());
}
}
TreeSet(比HashSet多了一个排序功能)
/**
* TreeSet: 数据结构是黑红二叉树，保存数据的唯一性同HashSet，同时增加的对象必须是可排序的
* <p>
* 排序方式：
* 1、 增加的对象类，实现Comparable接口
* 2、 创建比较器，需要创建类，并实现Comparator接口
*/
public class Demo {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
//添加对象时，先确保对象的唯一性，再调用String.compareTo(Object obj)比较大小
//默认排序方式：从小到大排序（依字符的ASCII码值或字符串长度）
treeSet.add("aaa");
treeSet.add("ccc");
treeSet.add("bbb");
treeSet.add("aaa");
treeSet.add("eee");
Iterator iterator = treeSet.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println(treeSet);//[aaa, bbb, ccc, eee]
}
}
TreeSet添加的元素必须实现Comparable接口
/**
* 实现Comparable接口
*/
public class Demo {
public static void main(String[] args) {
//方法一
TreeSet<Person> treeSet = new TreeSet();
treeSet.add(new Person("111"));
treeSet.add(new Person("444"));
treeSet.add(new Person("111"));
treeSet.add(new Person("222"));
treeSet.add(new Person("333"));
System.out.println(treeSet);//[111, 222, 333, 444]
//////////////////////////
//方法二
TreeSet<Animal> treeSet1 = new TreeSet(new MyCompartor());
treeSet1.add(new Animal(111));
treeSet1.add(new Animal(444));
treeSet1.add(new Animal(111));
treeSet1.add(new Animal(222));
treeSet1.add(new Animal(333));
System.out.println(treeSet1);//[111, 222, 333, 444]
}
//方法一
static class Person implements Comparable {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public int compareTo(Object o) {
return this.name.compareTo(((Person) o).name);
}
@Override
public String toString() {
return this.name;
}
}
//方法二
static class Animal {
private int age;
public Animal(int age) {
this.age = age;
}
@Override
public String toString() {
return this.age + "";
}
}
static class MyCompartor implements Comparator<Animal> {
@Override
public int compare(Animal animal, Animal t1) {
return animal.age - t1.age;
}
}
}