集合的基本使用
集合
集合框架构成及分类
ArrayList al = new ArrayList(); //需要进行类型转换
Iterator it = al.iterator(); //获取迭代器(可以解释为一种遍历方式)
Iterator<String> it = al.iterator(); //确定传入String时可以使用泛型绑定
只有列表迭代器才能，增删改查，其他迭代器只有删的功能
while(it.hasNext()) //判断是否存在下一个,存在返回true
it.next() //返回下一个对象并将指针移向下一位
ListIterator li = al.listIterator(); //列表特有的迭代器
//特有方法
hasprevious(); //逆向遍历元素，列表前一个位置有元素，则放回true
previous(); //返回列表的前一个元素
void remove() //从迭代去指向的Collection中移除迭代器返回的最后一个元素
Collection //集合
取出方式：
迭代器
for( : )
--List :元素是有序的，元素可以重复，因为该集合体系有索引
1 特有方法: 2 增： 3 add(index,element); //在指定位置增加元素 4 addAll(index,Collection); //在指定位置增加集合 5 删： 6 remove(index); //删除指定位置元素 7 改： 8 set(index,element); //更改指定位置元素 9 查： 10 get(index); //返回指定位置元素 11 subList(from,to); //获取子列表，从from到to, to越界会异常
listIterator(); //列表特有的迭代器
//特有方法
hasprevious(); //逆向遍历元素，列表前一个位置有元素，则放回true
previous(); //返回列表的前一个元素
indexOf(Object o); //返回第一次出现的指定元素的位置，若无，返回-1
lastIndexOf(Object o); //返回最后一次出现的指定元素的位置，若无，返回-1
ArrayList：底层数据结构使用的数组结构，特点：查询速度快，但增删稍慢，线程不同步
LinkedList：底层使用链表数据结构，特点：增删速度快，但查询慢
1 特有方法 2 获取 3 peekFirst(); //获取第一个元素 4 peekLast(); //获取最后一个元素 5 删 6 pollFirst(); //获取第一个元素，并删除元素 7 pollLast(); //获取最后元素，并删除元素 8 增 9 offerFirst(); 增加第一个元素 10 offerLast(); 增加最后一个元素
Vector：底层使用数据结构使用的数组结构，线程同步，被ArrayList取代
Enumeration枚举 //Vector特有取出方式，与迭代器相同，因为名称过长而被取代
--set ：元素是无序的，元素不可以重复, 底层使用了map方法
HashSet //数据结构以哈希表形式存储元素，
TreeSet //底层数据结构是二叉树，可以对set集合中的元素进行排序，
保证元素唯一性的依据
compareTo方法return 0;
TreeSet ts= new TreeSet
Comparable //强制让对象具备比较性
int compareTo(T o) //比较此对象与指定对象的顺序。
如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
TreeSet排序的第一种方法，让元素自身具备比较性，
元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然顺序。
1 //创建学生类，强制让学生具备比较性 2 class Student implements Comprable{ 3 ... ... 4 public int compareTo(Object obj){ 5 if(!(obj instanceof Student)) //判断类型是否为学生 6 throw new RuntimeException("不是学生对象"); //抛出异常 7 Student s = (Student)obj; //强制转换类型 8 if(this.age>s.age) //以年龄为排序依据 9 return 1; 10 if(this.age==this.age) //当年龄相同时，以名字为排序依据 11 return this.name.compareTo(s.name); 12 return -1; 13 } 14 ... ... 15 }
Comparator //强行对某个对象 collection 进行整体排序 的比较函数。
TreeSet的第二种比较方式，当元素自身不具备比较性时，
或者具备的比较性不是所需要时，
这时就需要让集合自身具备比较性，在集合的初始化时，就有了比较方法，
1 TreeSet ts = new TreeSet (new MyCompare()); //创建使用MyCompare()排序的TreeSet 2 //创建Mycompare排序，继承Comparator， 3 效果：当比较对象小于指定对象，返回负整数，大于时返回正整数，等于时返回0； 4 class Mycompare implements Comparator<父>{ //此处泛型可指定父类型继承此类型的子类可使用此方法 5 //重写compare()方法 6 public int compare(Object o1,Object o2){ 7 Student s1 = (Student)o1; 8 Student s2 = (Student)o2; 9 int num = s1.getName().compareTo(s2.getName()); //第一次比较当相等时返回0 10 if(num == 0){ 11 return new Integer(s1.getAge()).compareTo(new Integer(s2.age)); //第二次次等元素比较 12 } 13 return sum; 14 } 15 }
compare(T o1, T o2) //比较用来排序的两个参数。
boolean equals(Object obj) //指示某个其他对象是否“等于”此 Comparator。
1 例子 2 public static void main(String[] args) { 3 TreeSet ts = new TreeSet(); 4 ts.add("abs"); 5 ts.add("abx"); 6 ts.add("abb"); 7 ts.add("abc"); 8 Iterator it = ts.iterator(); 9 while(it.hasNext()) 10 System.out.println(it.next()); 11 } 12 输出结果： 13 abb 14 abc 15 abs 16 abx
1 事例 2 ArrayList al = new ArrayList(); 3 al.add("java01"); //添加对象 4 al.add("java02"); 5 al.add("java03"); 6 System.out.println(al+","+al.size());//返回对象个数 7 al.remove("java02"); //删除对象 8 al.clear(); //清空集合 9 System.out.println("java03是否存在："+al.contains("java03")); //判断某对象是否存在 10 System.out.println("集合是否为空：al.isEmpty()"); //判断集合是否为空 11 12 输出：[java01, java02, java03],3 13 java03是否存在：false 14 集合是否为空：true
1 方法 2 增加 3 addAll(Collection<>); //添加集合 4 删除 5 clear() //移出所有元素 6 al1.retainAll(al2); //保留al1中与al2相同的对象 7 al1.removeAll(al2); //移除al1中与al2相同的对象 8 boolean remove(Object o) //从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 9 判断 10 contains(Object obj) //判断是否包含元素 11 运用的是equals方法 12 isEmpty() //判断是否元素(不包含返回true) 13 containsAll(Collection<>); //判断是否包含集合 14 运用的是equals方法 15 获取 16 size() //返回元素个数 17 Object[] toArray() //返回包含所有元素的数组形式 18 int hashCode() //返回此 collection 的哈希码值。
Collections //服务于Collection的静态多态方法
此类不能实例化，就像一个工具类
Collections.max(); //使用方法
1 方法: 2 void copy(List<? super T> dest, List<? extends T> src) //将所有元素从一个列表复制到另一个列表。 3 查找 4 int binarySearch(List<? extends Comparable<? super T>> list, T key) //以二分法搜索在指定列表中的指定对象，返回坐标 5 若集合中不存在元素，返回(-(插入点) - 1) 6 Collections.binarySearch(list, "aaa"); //使用方法 7 第三参数，比较器 8 max(Collection<? extends T> coll) //根据自然顺序，返回最大元素,//第二参数，比较器 9 min(Collection<? extends T> coll) //根据自然顺序，返回最小元素,//第二参数，比较器 10 修改 11 顺序 12 Comparator<T> reverseOrder() //反转元素顺序，返回比较器 13 List list = new List(Collections.reverseOrder) //使用方法 14 Comparator<T> reverseOrder(Comparator<T> cmp) //可以将如参数，自定义比较器 15 List list = new List(Collections.reverseOrder(new comparator)) //使用方法 16 void sort(List<T> list) //根据自然顺序，列表升序排序, 第二参数，比较器 17 void swap(List<?> list, int i, int j) //交换列表中的元素位置 18 Collections.swap(list, 1, 2); //使用方法，将角标1与2元素换位 19 void shuffle(List<?> list) //将列表中元素随机放置 20 void reverse(List<?> list) //反转列表中元素顺序 21 替换 22 boolean replaceAll(List<T> list, T oldVal, T newVal) //将列表中某一值替换为另一个值 23 Collections.replaceAll(list,"aaa","qq") //使用方法 //将列表中的"aaa"替换为"qq" 24 void fill(List<? super T> list, T obj) //将指定元素替换列表中的所有元素 25 Collections.fill(list, "qq"); //使用方法 //将list中的所有元素替换为"qq" 26 可以写一个方法：将List中的某一段元素替换为其他元素
for(T t : t) //对集合t，或数组t进行遍历//局限性：必须有被遍历的目标，不能对集合进行操作
Map //集合(地图)
Map<K,V> //K为key，键，V为value，值，键与值只能传基本数据类型例如：Integer
每次存入都为一对一对
Map<String,String> map = new HashMap<String,String>();
取出方式：
Set<k> keySet //将amp中所有的键存入到set集合中
Set<Map.Entry<K,V>> entrySet() //将map集合的映射关系存入到set集合中
1 方法 2 增 3 V put(K key, V value) //添加元素，返回值 4 map.put("01","zhansan"); 5 如果出现添加，相同的键，那么会覆盖原有键的对应值 6 并返回被覆盖的值，第一次返回null 7 删 8 clear //移除所有 9 V remove(Object key) //删除键，返回值 10 判断 11 boolean containKey(Object key) //判断是否包含键与值 12 获取 13 V get(Object key) //返回指定键的值，如不存在则返回null 14 Collection<V> values() //返回集合的值 15 Set<k> keySet //将amp中所有的键存入到set集合中 16 因为set具备迭代器，所有可以以迭代方式取出所有的键， 17 根据get方法，获取每一个键对应的值 18 Set<Map.Entry<K,V>> entrySet() //将map集合的映射关系存入到set集合中 19 这个关系的数据类型是Map.Entry 20 Set<Map.Entry<String,String>> entrySet = map.entrySet(); 21 Iterator<Map.Entry<String,String>> it = entrySet.iterator(); //使用迭代器 22 while(it.hasNext()){ 23 Map.Entry<String,String> me = it.next(); 24 String key = me.getKey(); 25 String value = me.getValue(); 26 } 27 Map.Entry<K,V> 28 boolean equals(Object o) // 比较指定对象与此项的相等性。 29 K getKey() //返回与此项对应的键。 30 V getValue() // 返回与此项对应的值。 31 int hashCode() // 返回此映射项的哈希码值。 32 V setValue(V value) // 用指定的值替换与此项对应的值（可选操作）。
例子
1 Iterator iter = hashCode.entrySet().iterator(); 2 while (iter.hasNext()) { 3 Map.Entry entry = (Map.Entry) iter.next(); 4 Object key = entry.getKey(); 5 Object val = entry.getValue(); 6 System.out.println(key+"......"+val); 7 }
Hashtable //底层是哈希表结构，不可以存入null键null值，该集合线程同步, JDK1.0，效率低
HashMap //底层是哈希表结构，允许使用null键，null值，该集合不同步
JDK1.2，效率高
HashMap<String,String> hashMap = new HashMap<String,String>() //创建
hashMap.put("asdasd","sadasd"); //添加元素
Properties //可以用于储存键值对形势的软件配置信息
在加载数据时需要固定格式， 键=值
void load(InputStream inStream) //从输入流中读取属性列表（键和元素对）。
1 load(Reader reader) 2 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。 3 Proerties pro = new proerties(); 4 FileInputStream fileInput = new FileInputStream("demo.txt"); 5 FileOutputStream fileOutput = new FileOutputStream("demo.txt"); 6 pro.load(fileInput); //将文件流中的数据写入集合 7 pro.list(System.out); //输出
Object setProperty(String key, String value) //根据键，更改集合中的数据
void store(OutputStream out, String comments) //将集合中的数据保存入文件
void storeToXML(OutputStream os, String comment) //发出一个表示此表中包含的所有属性的 XML 文档。
void list(PrintStream out) //将集合中的数据输出
pro.list(System.out); //输出
String getProperty(String key) //通过键返回值
String getProperty(String key, String defaultValue)
用指定的键在属性列表中搜索属性。
，第二参数为默认值，若文件中无此键，则返回默认值，
无第二参数返回null；
TreeMap //底层是二叉树数据结构，线程不同步, 用于给map中的键进行排序,
Comparator //强行对某个对象 collection 进行整体排序 的比较函数。同TreeSet相同
compare(T o1, T o2) //比较用来排序的两个参数。
boolean equals(Object obj) //指示某个其他对象是否“等于”此 Comparator。
Comparable //强制让对象具备比较性
int compareTo(T o) //比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
比较器
Comparable //强制让对象具备比较性
int compareTo(T o) //比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
Comparator //强行对某个对象 collection 进行整体排序 的比较函数。
compare(T o1, T o2) //比较用来排序的两个参数。
boolean equals(Object obj) //指示某个其他对象是否“等于”此 Comparator。
