java 集合
集合
Collection接口
/ \
List接口 Set接口
/ \ / \
ArrayList类 LinkedList类 HashSet类 LinkedHashSet类
数组 链表 数组+链表 数组+双向链表（有序）
查找快 增删快
存重复的 有序存储 先进先出 存不重复的 无序存储 无下标
自定义的元素类重写hashCode()、equals()
数据存储的常用结构有：堆栈、队列、数组、链表
l堆栈
n先进后出 弹夹
n压栈：就是存元素。把元素存储到栈顶，栈中元素向下移动一个位置。
n弹栈：就是取元素。取出顶端位置元素，栈中元素向上移动一个位置。
l队列
n先进先出 安检
l数组 int[] arr={1,2,3};
n查找快： 通过索引 快速查找
n增删慢： 增：创建新数组 存储新元素 赋值 原数组
删：创建新数组 赋值 原数组（未删除的）
l链表 数据域+指针域
n多个节点之间，通过地址进行连接 多个人手拉手
n查找元素慢：通过连接的节点，依次向后查找指定元素
n增删元素快：修改连接下个元素的地址
Collection接口
Collection<String> coll = new ArrayList<String>(); //多态创建对象
Collection coll = new ArrayList(); //元素obj
coll.add("ab"); //true 添加 String元素对象
coll.add("cd"); coll.add(1);自动装箱 基本数值
coll.add("ef"); //确定string泛型后 编译报错
System.out.println(coll); // [ab, cd, ef] 打印集合 默认调用toString()
coll.remove("cd"); // true 删除元素 [ab, ef]
coll.contains("ab"); // true 集合是否包含指定元素
coll.size(); // 2 集合元素个数
coll.clear(); // [] 清空集合元素 void
coll.isEmpty(); // true 是否为空
// 遍历 集合 转 数组
String[] arr = coll.toArray(); Object[] arr=col.toArray(); // {"ab", "ef"}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);// String str=(String)arr[i];
//System.out.println(str.length());
}
// 遍历 集合 向下转型
ArrayList<String> arrL=(ArrayList<String>)coll; ArrayList arrL=(ArrayList)coll;
for(int i=0;i<arrL.size();i++){
System.out.println(arrL.get(i)); //String str=(String)a.get(i);
//System.out.println(str.length());
}
// 返回容器的迭代器对象 迭代器遍历时 增删 导致并发修改异常
Iterator<String> it = coll.iterator(); Iterator it = coll.iterator();
while(it.hasNext()){ // 是否有下一个可迭代元素 true/false
String str = it.next(); String str = (String) it.next();确定泛型后不强转
System.out.println(str.length());// 取出迭代的下一个元素 没元素 报错
}
for (Iterator it = coll.iterator(); it.hasNext(); ) {//迭代器for循环的形式的使用
System.out.println(it.next());
}
// 遍历 集合 增强for循环（JDK1.5）不能增删集合
//for(Object str : coll){ //底层是迭代器
for(String str : coll){ // Str为遍历集合的元素
System.out.println(str);
}
//int[] arr = new int[]{1,2};
Collections.sort(arr);//排序
Collections.shuffle(arr);//打乱顺序
for(int i:arr){
System.out.println(i);
}
泛型（在编译的时候 不进class文件 注释也不进 ）
含有泛型的类 创建类的 时候确定 泛型类型
class ArrayList<E>{ public boolean add(E e){ } public E get(int index){ } }
含有泛型的接口//迭代器接口
public interface Iterator<E> { public abstract E next(); }
实线或继承时明确泛型 只能传String类型
public final class Scanner implements Iterator<String> { public String next(){ } }
创建对象时，确定泛型的类型
ArrayList<String> list = new ArrayList<String>();
Iterator<String> it = list.iterator();
类型转换异常 提前到了编译时期 变成了编译失败。
传参时使用
泛型通配符<?> 只能用Object类的方法，元素自身方法无法使用
<? extends E> 接收E类或E的子孙类 的元素 E可以是接口（extends）
<? super E> 接收E类或E的祖宗类 的元素
class Dog extends Animal{ void kanjia(){...}}
class Cat extends Animal{ void zhuolaoshu(){...}}
public static void main(String[] args) {
ArrayList<Dog> arr=new ArrayList<Dog>();
arr.add(new Dog("旺财",10))
HashSet<Cat> set=new HashSet<Cat>();
set.add(new Dog("小花",8));
bianli(arr);
bianli(set);
}
public static void bianli(Collection<? extends Animal> col){ //<A及子类>
Iterator<? extends Animal> it=col.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj instanceof Dog){
Dog d=(Dog)obj;
System.out.println(d.kanjia());
}else if(obj instanceof Cat){
Cat c=(Cat)obj;
System.out.println(c.zhuolaoshu());
}
}
}
List接口
List<String> list=new ArrayList<String>();
list.add("a"); // 添加元素
list.add("b");
list.add(1,"c"); // 指定位置 添加元素
System.out.println(list); // [a,c,b]
//bollean flag=list.remove("c"); // 删除指定元素 true
String str=list.remove(2);// 指定索引删除元素
System.out.println(str); //c
System.out.println(list.get(0));//根据索引返回元素
list.size(); // 获取长度
list.set(1,"z"); // 替换索引处元素，返回被替换元素
for (int i = 0; i < list.size(); i++) {
String str = list.get(i); // 查看指定索引处元素
System.out.println(str);
}
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String str = it.next();
System.out.println(str);
}
int index = list.indexOf("php");//位置索引
boolean flag = list.contains("php");// 是否包含
LinkedList集合 链表结构增删快 coll接口共有方法+独有方法
LinkedList<String> link = new LinkedList<String>();
link.addFirst("a");// 指定元素添加到开头
link.addLast("b");// 指定元素添加到结尾
link.push("abc4"); // 默认添加到结尾
link.getFirst();// 查看第一个元素
link.getLast(); // 查看最后一个元素
link.removeFirst();//删除第一个元素
link.removeLast();//删除最后一个元素
link.pop()); //弹出集合中的栈顶元素
Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代
Vector<String> v=new Vector<String>(); //创建向量 同步 安全 慢
v.addElement("a");//添加元素
v.addElement("b");
v.addElement("c");
v.elementAt(1); //获取索引出元素
Enumeration<String> e=v.elements(); // 枚举器
while(e.hasMoreElements()){ // 判断是否有下一个元素
String str = e.nextElement();// 获取下一个元素
System.out.println(str);
}
Set接口 无序 无索引 不能存重复元素
HashSet集合
存放自定义对象，须重写hashCode和equals方法
contains()底层用的equals 不重写 判断地址是否重复
数组+链表
HashSet(): 初始容量16 加载因子0.75； 存到第12个时 自动扩容
set对象调用add()方法时
先调用hashCode()方法 得到hash值(地址计算) 无重复 存入集合
有重复 再调用equals()方法 无重复 存入集合 链入
数组： hash值 0x001 ox002
链表： 元素 a,10 a,11
b,9
import java.util.HashSet;
public class HashSetDemo2 {
public static void main(String[] args) {
Set<String> set=new HashSet<String>();
set.add("china");
set.add("hello"); // 无序
set.add("hello"); // false集合中不能存储重复元素
HashSet<Student> hs = new HashSet<Student>();//创建集合对象
hs.add(new Student("zhangsan",18)); //添加元素对象
hs.add(new Student("lisi",19));
hs.add(new Student("lisi",19));
//遍历集合对象
for (Student student : hs) {
System.out.println(student);
}
}
}
class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
public int hashCode() { //减少equals方法比较 提高效率
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
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 (age != other.age){return false;}//比较年龄是否相等
if (name == null) { //比较年龄是否相等
if (other.name != null){return false;}//只有一个为空
}
else if (!name.equals(other.name)){return false;} 值不相等
return true;
}
}
LinkedHashSet 双向链表 有序
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
Collections工具类
Collections.sort(list);//排序
int index = Collections.binarySearch(list,"a");// 二分查找(有序列表)
Collections.reverse(list);//反转列表元素
Collections.shuffle(list);//傻否，随机置换元素位置
Collections.swap(list,0,1);//列表中的两个索引进行位置互换
Collections.fill(list,"android");//使用指定对象 填充列表的所有元素
//创建目标列表 长度 大于等于 源列表
Collections.copy(listNew, listOld);//把源列表中的数据覆盖到新列表
