Java基础学习第七章之Java 集合

最新推荐文章于 2023-04-19 10:13:42 发布

liuc0317

最新推荐文章于 2023-04-19 10:13:42 发布

阅读量1.2k

点赞数

分类专栏： corejava

本文链接：https://blog.csdn.net/liuc0317/article/details/16827661

版权

corejava 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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);
		 
	}
  
}

liuc0317

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础学习第七章之Java 集合

Java 集合框架图：Java 集合类是一种特别的有用的工具类，可以存储数量不等的多个对象，也可以实现常用的数据结构，如栈、列队，Java 集合还提供了具用映射关系的存储方式。在java.unit.* 包下。Java 集合可以按他们的实现方法分为三大类，set、list、 map。set 用来存储不可重复的，无序的对象。list 用来存储可重复，有序的对象。ma
复制链接

扫一扫