Java集合
上一篇 / 下一篇 2017-11-11 09:10:56 / 个人分类:JavaSE
一、List 元素有序(储存数据顺序与迭代顺序一致或相反)
1.Vector : 底层数组实现,线程安全,效率低
2.ArrayList : 底层数组实现,线程不安全,效率高,较LinkedList查询快,增删慢
3.LinkedList : 底层链表实现,线程不安全,效率高,较ArrayList增删快,查询慢
二、Set 元素具有唯一性
1.HashSet : 底层哈希表(元素是链表的数组)实现,哈希表依赖哈希值存储。不保证元素的迭代顺序。此类允许使用null值元素。添加功能底层依赖两个方法:hashCode()、equals()
2.TreeSet : 底层二叉树结构,元素有序(比较方法排序):
自然排序:元素对象实现Comparable接口,重写compareTo()方法
import java.util.TreeSet;
public class TreeSetTest1 {
public static void main(String[] args) {
//自然排序
TreeSet<Student> set = new TreeSet<Student>();
set.add(new Student("年三",20));
set.add(new Student("王一",15));
set.add(new Student("牛二",20));
set.add(new Student("三年",15));
set.add(new Student("一王",17));
set.add(new Student("二牛",20));
for(Student s : set) {
System.out.println(s);
}
}
}
class Student implements Comparable<Student>{
private String name;
private int age;
/*年龄的数值 从小到大*/
public int compareTo(Student o) {
if(this.age > o.age)
return 1;
else if(this.age < o.age)
return -1;
else
//年龄相等情况:return 0——>不添加,return 1——>往前排,return -1——>往后排
return -1;
}
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public String toString() {
return "Student [name="+name+",age="+age+"]";
}
public int hashCode() {
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;
Student ther = (Student) 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;
}
}
3.LinkedHashSet
底层由哈希表和链表实现。哈希表保证元素的唯一性,链表保证元素具有可预知的迭代顺序
三、Map 存储键值对
1.HashMap
基于哈希表的Map实现,哈希表的作用是用来保证键的唯一性,键可以为null,值也可以为null,此实现是不同步的,效率高
2.TreeMap
键是二叉树结构,可以保证键的有序和唯一性,键不能为null(添加元素时,需要调用键的比较方法),值也不能为null
3.Hashtable
此类实现一个哈希表,哈希表将键映射到相应的值,键和值都不能为null(JDK1.0出现)
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest {
public static void main(String[] args) {
TreeMap map = new TreeMap();
map.put("one","1" );
map.put("two", "2");
map.put("three", "3");
//方式一
Collection collection = map.values();
for(Object v : collection) {
System.out.println("——>"+v);
}
//方式二
Set keySet = map.keySet();
for(Object k : keySet) {
System.out.println(k+"——>"+map.get(k));
}
//方式三
Set<Map.Entry> entrySet = map.entrySet();
for(Map.Entry e : entrySet) {
System.out.println(e.getKey()+"——>"+e.getValue());
}
}
}
四、Enumeration 和 Iterator 接口
Enumeration的效率比Iterator高,也使用更少的内存。Enumeration是非常基础的,也满足了基本需求。与Enumeration相比,Iterator更加安全,因为当一个集合中正在遍历的时候,它会阻止其它线程去修改集合。Iterator取代了Enumeration,允许调用者在迭代过程中移除元素,而Enumeration不能做到,为了使它的功能更加清晰,迭代器方法名已经经过改善。
五、Arrays类(数组工具类)
1.void sort(int[] a):对数组进行排序
2.int binarySearch(int[] a,int value):二分查找排好序的int类型数组中某个元素出现的下标
3.boolean deepEquals(Object[] o1,Object[] o2):比较两个数组的深度是否相等
4.void fill(int[] a,int value):将int类型数组中所有元素替换成指定int类型元素
5.int[] copyOf(int [] original,int newLength):复制数组中的元素,以使副本数组具有指定的长度
六、Collections类(集合工具类)
1.void sort(List list,Comparator c):使用比较器对集合进行排序
2.void shuffle(List list):打乱集合中的元素
3.T max(Collection c):获取集合中最大的元素
4.T min(Collection c):获取集合中最小的元素
5.void copy(List source,List target):将一个集合中的元素全部替换成指定的元素
七、泛型(Generic)
JDk 1.5开始,Java允许定义和使用泛型类、泛型接口、泛型方法
一种把类型明确的工作空间推迟到创建对象或者调用方法时明确,参数化类型的能力的特殊类型。
使用泛型的主要优点是能够在编译时而不是在运行时检测出错误
使用泛型来提高软件的可靠性和可读性1.泛型类
1.public class GenericTest1 {
2. public static void main(String[] args) {
3. GenericClass<Student> gc = new GenericClass<Student>();
4. gc.setObj(new Student("刘亦菲",20));
5. System.out.println(gc.getObj());
6. }
7.}
8.//泛型类
9.class GenericClass<T> {
10. private T obj;
11. public T getObj() {
12. return obj;
13. }
14. public void setObj(T obj) {
15. this.obj = obj;
16. }
17.}
18.class Student {
19. private String name;
20. private int age;
21. public Student() {
22. }
23. public Student(String name,int age) {
24. this.name = name;
25. this.age = age;
26. }
27. public void setName(String name) {
28. this.name = name;
29. }
30. public String getName() {
31. return name;
32. }
33. public void setAge() {
34. this.age = age;
35. }
36. public int getAge() {
37. return age;
38. }
39. public String toString() {
40. return "String [name="+name+",age="+age+"]";
41. }
42.}
2.泛型接口
1.public class GenericTest2 {
2. public static void main(String[] args) {
3. GenericInterface<String> gt = new Tool<String>();
4. gt.show("123");
5. }
6.}
7.//泛型接口
8.interface GenericInterface<T> {
9. public void show(T t);
10.}
11.class Tool<T> implements GenericInterface<T> {
12. public void show(T t) {
13. System.out.println(t);
14. }
15.}
3.泛型通配符
1.import java.util.Collection;
2.import java.util.ArrayList;
3.public class GenericTest3 {
4. public static void main(String[] args) {
5. Collection<Object> c1 = new ArrayList<Object>();
6. //?任意类型
7. Collection<?> c2 = new ArrayList<Object>();
8. //? extends E : 向下限定,E及其子类
9. Collection<? extends Animal> c3 = new ArrayList<Animal>();
10. Collection<? extends Animal> c4 = new ArrayList<Dog>();
11. //?super Animal : 向上限定,E及其父类
12. Collection<? super Animal> c5 = new ArrayList<Animal>();
13. Collection<? super Animal> c6 = new ArrayList<Object>();
14. }
15.}
16.class Animal {
17.}
18.class Dog extends Animal {
19.}
20.class Cat extends Animal {
21.}
TAG: