一.集合类
Java中数组与集合的比较
1.数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
2.数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象
Java中集合框架层次结构
Collection接口
1.一组称为元素的对象
2.一个Collection中可以放不同
类型的数据
1.是Set接口和List接口的父类
2.是否有特定的顺序以及是否允许重复，取决于它的实现
3.Set － 无序的集合；不允许重复 如：HashSet
4.List － 有序的集合；允许重复 如：ArrayList,LinkedList
Set接口
1.Collection的子接口
2.用来包含一组 无序无重复 的对象
3.无序-----是指元素存入顺序和集合内存储的顺序不同
4.无重复------两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复
Set接口的实现类
1.HashSet-----HashSet的特性在于其内部对象的散列存取，即采用哈希技术
2.TreeSet-----TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的
List接口
1.Collection的子接口
2.用来包含一组 有序有重复 的对象
3.List中的元素都对应一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素
4.List有两种主要的集合实现类：ArrayList,LinkedList
List接口的实现类
1.ArrayList是线性顺序存储的，是一种线性表
2.它的特性和数组很接近，数组大小是不变的，而ArrayList的大小是可以动态改变的
3.LinkedList最主要的功能方面的增强是可以在List的头部和尾部添加、删除、取得元素，直接提供了这些方法的实现
ArrayList与LinkedList的比较
存储结构
1.ArrayList是线性顺序存储
2.LinkedList对象间彼此串连起来的一个链表
操作性能
1.ArrayList适合随机查询的场合
2.LinkedList元素的插入和删除操作性高
Map接口
1.Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象
2.Map是不同于Collection的另外一种集合接口
3.Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
Map接口有两个实现：
1.HashMap — key/value对是按照Hash算法存储的
2.TreeMap — key/value对是排序(按key排序)存储的
HashMap与TreeMap的比较
1.HashMap基于哈希表实现
2.TreeMap基于树实现
3.HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用
4.TreeMap没有调优选项，因为该树总处于平衡状态
5.HashMap性能优于TreeMap
Iterator接口
1.Iterator对象称作迭代器，用来方便的实现对容器内的元素进行遍历操作
2.所有实现了Collection接口的集合类都有一个iterator( )方法，返回一个实现了Iterator接口的对象
3.Iterator对象实现了统一的一个用来遍历Collection中对象的方法
4.Iterator是为遍历而设计，能够从集合中取出元素和删除元素，但是没有添加元素的功能
5.Iterator的功能上比较简单，使用中，只能单向移动
hasNext方法
用来判断指针右边是否还有数据
Next方法
将指针向右移动一次，将划过的数据取出来
Iterator<String> iter=hs1.iterator();
while(iter.hasNext()){ System.out.println( iter.next()); }
如何选择集合类
1.Set内存放的元素不允许重复，List存放的元素有一定的顺序
2.Map的应用主要在利用键/值对进行快速查询
3.ArrayList和LinkedList的区别在于随机查询性能上ArrayList要好，但LinkedList的中间元素的插入与删除性能好
4.HashSet和TreeSet的区别在于集合内元素是否排序
collection接口
1 package util1;
2
3 import java.util.Collection;
4 import java.util.HashSet;
5
6 public class Collection1 {
7
8 /**
9 * @param args
10 */
11 public static void main(String[] args) {
12
13 //实例化对象
14 Collection c1=new HashSet(); //向上转型--- 声明成接口类型，调用实现类的构造方法
15 Collection c2=new HashSet();
16 //添加数据
17 c1.add(1);
18 c1.add("你");
19 c1.add(new A());
20
21 System.out.println(c1); //整体取出数据：直接输出集合名称
22
23 c2.addAll(c1); //添加其他集合
24 System.out.println(c2.size()); //取集合长度
25 System.out.println(c2.contains("sgtht")); //判断是否包含某些数据
26
27 System.out.println("///////////////");
28 Object o[] =c2.toArray(); //将集合转换成数组
29 /*for(int i=0;i<o.length;i++){
30 System.out.println(o[i]);
31 }*/
32
33 System.out.println(o[0]);
34 System.out.println(o[1]);
35 System.out.println(o[2]);
36
37
38 }
39
40 }
set集合
hashSet,treeSet
1 package util1;
2
3 import java.util.HashSet;
4 import java.util.Iterator;
5 import java.util.TreeSet;
6
7 public class HashSet1 {
8
9 /**
10 * set接口的特点(集合)
11 * hashset: 无顺序,数据不能重复,长度可扩展
12 * treeset: 按照自然顺序排列数据，数据不能重复,能够比较大小
13 *
14 */
15 public static void main(String[] args) {
16
17 HashSet<String> hs1=new HashSet<String>();
18 hs1.add("a");
19 hs1.add("b");
20 hs1.add("b");
21 hs1.add("c");
22 /* System.out.println(hs1);
23
24 //挨个取出集合中的数据
25 Iterator<String> iter=hs1.iterator();
26 while(iter.hasNext()){
27 System.out.println( iter.next());
28 }
29 */
30
31
32 TreeSet<Integer> ts1=new TreeSet<Integer>();
33 ts1.add(1);
34 ts1.add(768);
35 ts1.add(43);
36 ts1.add(43);
37 ts1.add(87);
38 System.out.println(ts1);
39
40
41 //类型转换异常
42
43 TreeSet ts2=new TreeSet();
44 ts2.add("adsf");
45 ts2.add("u11");
46 ts2.add("caa");
47 System.out.println(ts2);
48 }
49
50 }
list集合
linkedList
1 package util1;
2
3 import java.util.HashSet;
4 import java.util.Iterator;
5 import java.util.LinkedList;
6
7 public class List1 {
8
9 /**
10 * list（列表）: 下标从0开始
11 *
12 * linkedList: 方便首尾操作 ， 数据可重复,有顺序,长度可扩展
13 * ArrayList:(数组列表) : 数据可重复,有顺序,长度可扩展
14 *
15 */
16 public static void main(String[] args) {
17
18 LinkedList<Integer> ll=new LinkedList<Integer>();
19 ll.add(1);
20 ll.add(454);
21 ll.add(454);
22 ll.add(454);
23 ll.add(454);
24 ll.add(242);
25 ll.add(0, 88);
26 //ll.add(10, 77);
27 System.out.println(ll);
28 ll.addFirst(66);
29 System.out.println(ll);
30 System.out.println(ll.get(4)); //按照下标取数据
31
32 System.out.println("///////////////////");
33
34 for(int i=0;i<ll.size();i++){
35 System.out.println(ll.get(i));
36 }
37
38 System.out.println("///////////////////");
39
40 Iterator<Integer> it=ll.iterator();
41 while(it.hasNext()){
42 System.out.println(it.next());
43 }
44
45 System.out.println("///////////////////");
46 //foreach循环,增强的for循环------提高效率(封装了迭代器)
47 for(Integer in:ll){
48 System.out.println(in);
49 }
50
51 }
52
53 }
map接口
hashmap集合
1 package util1;
2
3 import java.util.HashMap;
4 import java.util.Iterator;
5 import java.util.Map;
6 import java.util.Set;
7 import java.util.Map.Entry;
8
9 public class Map1 {
10
11 /**
12 * map:数据成对存放
13 * HashMap: 无序存放 key值不能重复，如果key值重复，会替换掉原来的键值对
14 *
15 *
16 */
17 public static void main(String[] args) {
18 //声明键值对容器
19 HashMap hm1=new HashMap<String, String>();
20
21 hm1.put("1", "a");
22 hm1.put("2", "b");
23 hm1.put("2", null);
24 hm1.put("3", "c");
25 System.out.println(hm1);
26
27 Set keys=hm1.keySet(); //将所有key值取出组合成一个set集合
28 /* Iterator<String> it=keys.iterator();
29 while(it.hasNext()){ //循环所有key值
30 // System.out.println(hm1.get(it.next())); //根据key值获取value值
31 }*/
32
33
34 Map<String, String> m1=new HashMap<String, String>();
35 //向上转型: 节省内存 ,可用接口中的方法，实现类重写的方法,不能用实现类独有的方法
36 m1.put("1", "a");
37 m1.put("2", "b");
38 m1.put("2", "c");
39 m1.put("3", "c");
40 System.out.println(m1);
41
42 Set<Map.Entry<String, String>> ens=m1.entrySet();
43 for(Entry<String, String> e:ens){
44 System.out.println(e.getKey());
45 System.out.println(e.getValue());
46 }
47
48 }
49
50 }
treemap集合
1 package util1;
2
3 import java.util.TreeMap;
4
5 public class TreeMap1 {
6
7 /**
8 * treemap: 按照key值的自然顺序排列数据,要求key值可以比较大小
9 */
10 public static void main(String[] args) {
11
12 TreeMap tm1=new TreeMap<Integer, String>();
13 tm1.put(44, "gf");
14 tm1.put(4654, "gf");
15 tm1.put(42, "gf");
16 tm1.put(4, "gf");
17 System.out.println(tm1);
18 System.out.println(tm1.floorKey(5)); //得到小于参数的一个key值
19 System.out.println(tm1.floorEntry(5)); //得到小于参数的一个键值对
20
21 }
22
23 }
日期
1 package util1;
2
3 import java.text.SimpleDateFormat;
4 import java.util.Calendar;
5 import java.util.Date; //引包
6
7 public class Date1 {
8
9
10 public static void main(String[] args) {
11
12 //当前时间
13 Date d1=new Date(); //当时的时间
14 System.out.println(d1);
15
16 SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 a hh:mm:ss");
17 String time1=sdf.format(d1);
18 System.out.println(time1);
19
20
21 //日历类
22 Calendar c= Calendar.getInstance(); //反转获得时间
23 c.set(2011,11,29); //自定义的时间
24 System.out.println(c.get(Calendar.YEAR));
25
26 }
27
28 }