Java基础学习第七章之Java 集合
Java 集合框架图：
Java 集合类是一种特别的有用的工具类，可以存储数量不等的多个对象，也可以实现常用的数据结构，如栈、列队，Java 集合还提供了具用映射关系的存储方式。在java.unit.* 包下。
Java 集合可以按他们的实现方法分为三大类，set、list、 map。
set 用来存储不可重复的，无序的对象。
list 用来存储可重复，有序的对象。
map 用来存储键值对 的对象。
set 、list 接口是Collection 的主要实现。hashmap 是 map 的主要实现。 set 集合访问集合中的元素只能通过元素本身来访问，list 可以通过索引来访问，map 可以通过 key 来访问 value.
Collection 和 iterator 接口:
Collection 是 set、list、queue 接口的父接口，提供了很多操作元素的方法。
boolean add(Object o); // 用于向集合中添加一个对象的方法，添加成功返回true,否则返回false.
boolean addAll(Collection c)// 用于向集合添加一个集合元素，添加成功返回true,否则返回false.
Iterator 、foreach 的使用：
package com.soliucheng.domain;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
public class CollectionTest {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
// collection 的基本方法使用
Collection coll = new ArrayList();
coll.add("java基础"); // 添加元素
coll.add(1); //没使用泛型 所以任何对象都可以放到集合中，都会当作 Object 对象来处理
System.out.println("集合元素个数"+coll.size());//集合个数
coll.remove(1);//移除某一个元素
System.out.println("集合删除后的元素个数"+coll.size());
boolean contains = coll.contains("java基础");//是否包含某个元素
System.out.println(contains);
System.out.println(coll.isEmpty());//集合是不是空的
// coll.clear();// 清除集合中的所元素 将集合中的数据长度变为0
Collection books = new ArrayList();
books.add("java 基础");
books.add("java基础");
// books.removeAll(coll); //从集合中删除集合coll里包含的所元素，如果coll 集合中包含的元素也在books 集合中 就把books 集合的元素移除
books.retainAll(coll);// 删除集合books 与 coll 中不同的元素。如果books 包含的元素 coll 中也包含，而books 中包含的元素，而coll 中不包含 就把books 中包含的元素删除
System.out.println(books);
// Iterator 的使用
List list = new ArrayList();
list.add("张");
list.add(100);
list.add(4.34);
list.add(true);
// 当使用iterator 对集合元素进行迭代时，Iterator 并不是把集合元素本身传给了迭代变量，
//而是把集合元素的值传给了迭代变量，所以修改迭代 变量的值对集合元素本身并没影响
Iterator iter = list.iterator();
while(iter.hasNext()){
Object result = iter.next();
System.out.println(result.toString());
if(result.equals("张")){
iter.remove();
}
result="李四";// 对集合本身没影响
// list.add("王五"); 当使用 iterator 操作集合时，不能再进行新增元素，否则报 java.util.ConcurrentModificationException 异常
}
System.out.println("-------------------------------");
// foreach JDK 1.5 时，新增了foreach 来迭代集合或是数组。
for (Object object : list) {
System.out.println(object.toString());
}
}
}
集合 set 的使用 ：set 就是一个罐子，把对象放到set 集合中，就没了顺序，基本上和collection 的用法一样，set 不容许包含相同的元素，如果试着把相同的元素放到set 集合中，首先，会比较两个对象的equals 是否相等，如果，相等，就会返回false.添加失败。set 集合是不同步的(线程不安全)，如果，多条线程同时操作集合时，要使用代码，保证其同步。
代码如下：
package com.soliucheng.domain;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
public class CollectionTest {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
/*
* set 就是一个罐子，把对象放到set 集合中，就没了顺序，基本上和collection 的用法一样，
* set 不容许包含相同的元素，如果试着把相同的元素放到set 集合中，首先，会比较两个对象的equals 是否相等，
* 如果，相等，就会返回false.添加失败。
*/
Collection coll = new HashSet(); // 多态的表现，子类对象赋值给父类变量
boolean first= coll.add(new String("abc")); // 添加一个新对象 返回 true
System.out.println(first);
boolean second= coll.add(new String("abc")); // 添加一个新对象 返回 false
System.out.println(second);
boolean three = coll.add(null);// set集合允许 存存 null 值
System.out.println(three);
System.out.println(coll.size()); // 1
/*
* set 的常用实现是HashSet 类，set 是用在数据结构上使用散列表存放，首先，获取对象的hashCode, 跟据这个hashCode值 决定存储在什么位置、
* 然后，查看该位置是否存是对象，如果存在，就会比较eqauls 相等，不相等就存放，相等就不存放。
* 所以，要放到set 集合中的对象，要重写 equals 和 hashCode 方法，保存 equals 返回true 时，hashCode 也返回true.
* LinkedHashSet 也是 set 集合的常用实现，跟据， hashCode 算出他将要存储的位置，同时，使用双向链表维护其顺序，所以性能会给hashCode 低。
*/
Set set = new LinkedHashSet();
set.add("abc"); // 添加元素
set.add("abcd");
set.remove("abc");// 移除元素
set.add("abc");
System.out.println(set);//[abcd, abc] 和添加的顺序一致
}
}
结果：
true
false
true
2
[abcd, abc]
集合 list 的使用：list 集合允许存放重复的元素，可以保证其顺序，内部采用数组来存放，可以使用索引来获取元素。
list 接口实现子类实现有ArrayList 和 linkedList. 同时，提供了一些根据索引来操作元素的方法。
代码如下：
package com.soliucheng.domain;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Stack;
public class CollectionTest {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
List books = new ArrayList();
books.add("java基础");
books.add("java基础"); // 允许重复元素
books.add(0,"计算机编译原理");
books.add("javaEE");
String book = (String)books.get(0);
System.out.println(book);//计算机编译原理
System.out.println(books);//[计算机编译原理, java基础, javaEE]
for(int i=0;i<books.size();i++){
System.out.println(books.get(i)); // 通过索引获取元素
}
boolean removeResult = books.remove("javaEE");//books.remove(index);
System.out.println(removeResult); // true
System.out.println(books);//[计算机编译原理, java基础]
books.set(0,"javaWeb");//用指定元素替换列表中指定位置的元素
// 泛型 在后边讲
List<String> bookList = books.subList(0,books.size());//返回列表中指定的 fromIndex（包括 和 toIndex（不包括之间的部分视图。
System.out.println(bookList);//[javaWeb, java基础]
List ll = new LinkedList<String>(); // 和 ArrayList 使用组数和双向链表实现，适合于平凡增删，不使用索引获取对象的情况
/*
* list 实现了 listIterator 提供了向前迭代的方法
*/
System.out.println("-----------ListIterator 的使用---------------------------------");
ListIterator<String> listIt = books.listIterator(); // 返回一个 ListIterator 对象
while(listIt.hasNext()){//正向迭代
System.out.println(listIt.next());//获取迭代结果
listIt.add("-----------");// 给listIt 添加元素。 在set 的iterator 中 会报异常
}
while(listIt.hasPrevious()){ // 反向迭代
System.out.println(listIt.previous());// 获取反向迭代的结果
}
System.out.println("-----------ListIterator 的使用 结束---------------------------------");
}
}
结果：
计算机编译原理
[计算机编译原理, java基础, java基础, javaEE]
计算机编译原理
java基础
java基础
javaEE
true
[计算机编译原理, java基础, java基础]
[javaWeb, java基础, java基础]
-----------ListIterator 的使用---------------------------------
javaWeb
java基础
java基础
-----------
java基础
-----------
java基础
-----------
javaWeb
-----------ListIterator 的使用 结束---------------------------------
list 的Vector 的经典实现：
/*
* Vector 做为 List 的经典实现，在 jdk 1.0 时就，是一个线程安全的集合，所以操作速度要慢一点。
* vector 的子类 Stack 还提供了栈的实现，压栈，后进先出 last in fist out LIFO
* 常用方法：
* Ojbect peek();返回栈中的第一个元素，但并不将元素移除。
* Object pop();;返回栈中的第一个元素，并不将元素移除。
* void push(Object item); 向栈中新增一个元素
*/
Stack stack = new Stack();
stack.push("dog");
stack.add(0, "tiger");
System.out.println(stack);//[tiger, dog]
Object obj = stack.peek(); // 返回栈中的第一个元素，但并不将元素移除。
System.out.println(obj.toString());//dog
System.out.println(stack);//[tiger, dog]
Object obj1 = stack.pop();//;返回栈中的第一个元素，并不将元素移除。
System.out.println(obj1.toString());//dog
System.out.println(stack);//[tiger]
结果：
[tiger, dog]
dog
[tiger, dog]
dog
[tiger]
固定长度的List:
/*
* 固定长度的List 只能遍历 操作，不能修改List
*/
List<String> ssh = Arrays.asList("Struts","spring","hibernate");
for(int i =0;i<ssh.size();i++){
System.out.println(ssh.get(i));
}
//ssh.add("MyBats");// 不能修改 list java.lang.UnsupportedOperationException
Queue 操作的实现：queue 是队列的实现 ，先进先出，first in first out . 常用的 linkedList
代码如下：
/*
* 队列 queue的实现 常用的 linkedList
*/
LinkedList queue= new LinkedList();// 队列的实现
queue.offer("Struts1");
queue.offer("Struts2");
queue.offer("Struts3");
queue.offer("Struts4");
System.out.println(queue.size());
queue.add("spring"); // 添加元素
System.out.println(queue.size());
Object obj2 = queue.peek(); // 获取 队列最早的元素 ，并不会 把这个元素 移除
System.out.println(obj2);
Object obj3 = queue.poll(); // 获取 队列最早的元素 ，会 把这个元素 移除
System.out.println(queue);
queue.addFirst("mybatis");
System.out.println(queue);
结果：
4
5
Struts1
[Struts2, Struts3, Struts4, spring]
[mybatis, Struts2, Struts3, Struts4, spring]
Map 的使用：用来存储key -value 对的映射关系，所以要存储两组元素，一组用来存储map 里的key ,另一组用来存储map里的value.key 和 value 可以是任何的引用类型，map 里的key 不能重复，如果要把key 重复的元素放到map 里，equals 比较总返回false,存放失败，value 可以重复 也可以为null. key的集合叫keySet,没有顺序，所以不能重复，实现上类似于set,而value 可以重复，则实现要类似于list.常用实现类有HashMap 和Hashtable，properties,linkedHashMap。Hashtable 和 HashMap 的区别：
Hashtable 是老式的HashMap 是在 jdk 1.0 的时候的API.是线程安全的.Hashtable 没有遵守java命名规则，每个首字母大写，因为使用的太多了，所以 Hashtable 不能修改了。HashMap 是线程不安全的，所以要多线程访问时，要用代码同步。
Hashtable 不可以使用null 做为 Key和value,而HashMap 则可以。
代码如下：
package com.soliucheng.domain;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
public class CollectionTest {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
List books = new ArrayList();
books.add("java基础");
books.add("java基础"); // 允许重复元素
books.add(0,"计算机编译原理");
books.add("javaEE");
String book = (String)books.get(0);
System.out.println(book);//计算机编译原理
System.out.println(books);//[计算机编译原理, java基础, javaEE]
for(int i=0;i<books.size();i++){
System.out.println(books.get(i)); // 通过索引获取元素
}
boolean removeResult = books.remove("javaEE");//books.remove(index);
System.out.println(removeResult); // true
System.out.println(books);//[计算机编译原理, java基础]
books.set(0,"javaWeb");//用指定元素替换列表中指定位置的元素
// 泛型 在后边讲
List<String> bookList = books.subList(0,books.size());//返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
System.out.println(bookList);//[javaWeb, java基础]
List ll = new LinkedList<String>(); // 和 ArrayList 使用组数和双向链表实现，适合于平凡增删，不使用索引获取对象的情况
/*
* list 实现了 listIterator 提供了向前迭代的方法
*/
System.out.println("-----------ListIterator 的使用---------------------------------");
ListIterator<String> listIt = books.listIterator(); // 返回一个 ListIterator 对象
while(listIt.hasNext()){//正向迭代
System.out.println(listIt.next());//获取迭代结果
listIt.add("-----------");// 给listIt 添加元素。 在set 的iterator 中 会报异常
}
while(listIt.hasPrevious()){ // 反向迭代
System.out.println(listIt.previous());// 获取反向迭代的结果
}
System.out.println("-----------ListIterator 的使用 结束---------------------------------");
/*
* Vector 做为 List 的经典实现，在 jdk 1.0 时就有，是一个线程安全的集合，所以操作速度要慢一点。
* vector 的子类 Stack 还提供了栈的实现，压栈，后进先出 last in fist out LIFO
* 常用方法：
* Ojbect peek();返回栈中的第一个元素，但并不将元素移除。
* Object pop();;返回栈中的第一个元素，并不将元素移除。
* void push(Object item); 向栈中新增一个元素
*/
Stack stack = new Stack();
stack.push("dog");
stack.add(0, "tiger");
System.out.println(stack);//[tiger, dog]
Object obj = stack.peek(); // 返回栈中的第一个元素，但并不将元素移除。
System.out.println(obj.toString());//dog
System.out.println(stack);//[tiger, dog]
Object obj1 = stack.pop();//;返回栈中的第一个元素，并不将元素移除。
System.out.println(obj1.toString());//dog
System.out.println(stack);//[tiger]
/*
* 固定长度的List 只能遍历 操作，不能修改List
*/
List<String> ssh = Arrays.asList("Struts","spring","hibernate");
for(int i =0;i<ssh.size();i++){
System.out.println(ssh.get(i));
}
// ssh.add("MyBats");// 不能修改 list java.lang.UnsupportedOperationException
/*
* 队列 queue的实现 常用的有 linkedList
*/
LinkedList queue= new LinkedList();// 队列的实现
queue.offer("Struts1");
queue.offer("Struts2");
queue.offer("Struts3");
queue.offer("Struts4");
System.out.println(queue.size());
queue.add("spring"); // 添加元素
System.out.println(queue.size());
Object obj2 = queue.peek(); // 获取 队列最早的元素 ，并不会 把这个元素 移除
System.out.println(obj2);
Object obj3 = queue.poll(); // 获取 队列最早的元素 ，会 把这个元素 移除
System.out.println(queue);
queue.addFirst("mybatis");
System.out.println(queue);
/*
*map 的实现
*/
Map map = new HashMap();
map.put(null,null); // 可以使用null 作为 key
Object o = map.put("a",1233);
Object o1 = map.put("a", "abc1");// 返回同key 的比较元素key 对应的值 ,同时，把前一个key 相同的value 给覆盖
System.out.println("--"+o1.toString());// --1233
map.put("b", 234);
for(Object key :map.keySet()){
System.out.println(map.get(key));
}
System.out.println("----------------------------------");
Set keyValues = map.entrySet();// 返回 key=value 的集合
Iterator iter = keyValues.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
System.out.println("---------------Hashtable-------------------");
Hashtable table = new Hashtable();
table.put("a", "abc"); // hashtable 不能把null 作为key 或是 value 使用
System.out.println(table.size());
System.out.println("---------------Properties-------------------");
Properties prop = new Properties();// 通常用来读取配置文件。file.properites
// InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("file.properties");
try {
FileInputStream is = new FileInputStream("file.properties");
prop.load(is);
String ip = (String)prop.get("IP"); // 获取key=IP的值的value
System.out.println(ip);
prop.put("PORT","8080");
prop.store(new FileOutputStream("file.properties"), "Update PORT value");
} catch (IOException e) {
e.printStackTrace();
}
List list = new ArrayList<String>();
List<Object> listO = Collections.synchronizedList(list);
}
}