Java-Collection和Map

最新推荐文章于 2024-04-28 17:20:37 发布
最新推荐文章于 2024-04-28 17:20:37 发布
阅读量183 收藏
点赞数 1
分类专栏： Java 文章标签： java基础
原文链接：www.baidu.com
版权

文章目录

1. 什么是集合

  • 容器 存储元素的集合

2. 集合的继承树

在这里插入图片描述
在这里插入图片描述

3. 为什么要使用集合

  • ①可以实现动态添加数据 不用考虑是否超出集合的存储范围
  • ②集合中提供了丰富的类以及类的方法 可以实现对集合数据进行各种操作
  • ③集合中提供了多个接口和具体的实现类 可以存储多种特点的数据
    • 有序可重复
    • 无序不可重复
    • 键值对

4.集合的分类

  • Collection接口
  • Map接口

5.Collection接口（单列集合）

        5.1 Collection 都有哪些具体的实现类

在这里插入图片描述

        5.2 Collection接口中的抽象方法：
// 增加
add(Object obj);
addAll(Collection coll);
// 删
remove(Object obj);
removeAll(Collection coll);
clear();
// 查
contains(Object obj);
//当前集合中，是否包含 coll集合中的所有元素
containsAll(Collection coll);
// 遍历
iterator();

size();
isEmpty();
//获取当前集合和 coll集合的相同的元素，并返回给当前集合
retainAll(Collection coll);
// 如果当前集合与 obj集合中的元素完全相同 则返回true
equals(Object obj)

hashCode();
// 集合转位为数组
toArray();
        5.3 List具体的实现类
  • ArrayList
//构造一个初始容量为 10 的Object数组。最大容量为MAX-8。
//空间不足时 扩容1.5倍 复制就的数据到新的list中
ArrayList()：
//将Collection 集合转化为Arraylist 集合返回
ArrayList(Collection<? extends E> c)
// 构造一个具有指定初始容量的空列表。
// 如果知道数据的长度 建议使用该构造器
ArrayList(int initialCapacity)
  • ArrayList、LinkedList、Vector三者的异同？
    • 1.都是作为List接口的实现类，可以用来存储有序的、可以重复的数据
    • 2.ArrayList：线程不安全的，效率高;(使用Collections类的方法转为线程安全的)；
      • Vector:作为List接口的古老类；Vector线程安全的，效率低；底层使用数组实现
      • LinkedList:底层使用双向链表实现的；对于频繁的删除，插入操作，建议使用LinkedList


public class CollectionTest {
	@Test
	public void test3(){
		Collection coll = new ArrayList();
		coll.add(new String("AA"));
		coll.add(new Person("Tom",12));
		coll.add("BB");
		coll.add(123);
		coll.add(456);
		//8.retainAll(Collection coll):获取当前集合和coll集合的相同的元素，并返回给当前集合
//		Collection coll1 = Arrays.asList(new Integer[]{123,456});//数组--->集合
//		coll.retainAll(coll1);
		System.out.println("****************");
		System.out.println(coll);
		
		//9.remove(Object obj):从当前集合中将obj元素删除 返回值为boolean
	      coll.remove(123);
//	      coll.remove(new Person("Tom",12));
			System.out.println("****************");
			System.out.println(coll);
	      
		//10.removeAll(Collection coll): 从一个集合中删除另一个集合 也就是求差集
			System.out.println("****************");
			Collection coll1 = Arrays.asList(new Integer[]{123,456,125});
			coll.removeAll(coll1);
			
			System.out.println(coll);

		//11.equals(Object obj):如果当前集合与obj集合中的元素完全相同 则返回true
			boolean equals = coll.equals(coll1);
			System.out.println(equals);
		//12.hashCode():
		System.out.println(coll.hashCode());
		//13.toArray()  集合到数组的转换
		System.out.println(coll);
		Object[] array = coll.toArray();
		for(int i=0;i<array.length;i++){
		System.out.println(array[i]);}
		//14.iterator():遍历
	}
	
	@Test
	public void test2(){
		Collection coll = new ArrayList();
		coll.add(new String("AA"));
		coll.add(new Person("Tom",12));
		coll.add("BB");
		coll.add(123);//自动装箱
		
		//6.contains(Object obj):判断集合中是否包含obj元素。判断标准：调用obj所在类的：equals()
		boolean isExist = coll.contains(new String("AA"));
		System.out.println(isExist);
		
		isExist = coll.contains(new Person("Tom",12));
		System.out.println(isExist);//false--->true
		
		//7.containsAll(Collection coll1):当前集合中，是否包含coll集合中的所有元素
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add("BB");
		System.out.println("7." + coll.containsAll(coll1));
	}
	
	@Test
	public void test1(){
		Collection coll = new ArrayList();
		//1.add(Object obj):将obj添加到集合中
		coll.add("AA");
		coll.add("BB");
		coll.add(123);//自动装箱
		coll.add(new Person("Tom",12));
		
		//2.size():获取集合中存储的元素的个数
		System.out.println(coll.size());
		
		System.out.println(coll);
		//3.addAll(Collection coll):将coll中的元素添加到当前的集合中。
		Collection coll1 = new ArrayList();
		coll1.add(111);
		coll1.add("MM");
		coll1.add("GG");
		coll.addAll(coll1);
//		coll.add(coll1);
		System.out.println(coll);
		
		
		//5.clear():清空集合元素
		coll.clear();
		
		//4.isEmpty():判断集合是否为空
		System.out.println(coll.isEmpty());
	}
}



package com.atguigu.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.junit.Test;

/**
 * java.util.Collection:单列数据
 *   	|------List子接口：存储有序的、可重复的数据 ---->"动态"数组
 *   		|-----ArrayList:作为List的主要实现类；线程不安全的，效率高；底层使用数组实现
 *               （Collections中定义了synchronizedList(List list)将此ArrayList转化为线程安全的）
 *   		|-----LinkedList:对于频繁的插入、删除操作，我们建议使用此类，因为效率高；底层使用双向链表实现
 *   		|-----Vector:List的古老实现类；线程安全的，效率低；底层使用数组实现
 *   
 *   
 *   [面试题] ArrayList、LinkedList、Vector区别？
 *   		共同点：ArrayList、LinkedList、Vector都是List接口的实现类，存储的数据都是有序的、可重复的。
 *          区别：如上
 *          
 *          List list = new ArrayList();//jdk 7.0 : Object[] elementData = new Object[10];
 *          sysout(list.size());//0
 *          list.add(..);//elementData[0] = ..
 *          ...
 *          ...
 *          一旦要添加的元素超出了底层数组的长度，就需要扩容，默认扩容为原来的1.5倍，同时，需要将原有数组
 *       中的元素复制新的数组中。
 *          ...
 *          
 *       实际情况：需要存储80个数据到ArrayList中，建议：List list = new ArrayList(85);
 *   		
 * 
 * 
 * 说明：1.向List中添加自定义类的对象的话，要求此自定义类重写equals()方法！
 *      2.补充：数据结构解决两个问题：
 *             1.数据之间逻辑关系：一对一，一对多，多对多，...
 *             2.数据的存储结构：①顺序存储：一维数组  ②链式存储
 * 
 * 
 * 
 * @author shkstart 邮箱：shkstart@126.com
 * @version  创建时间：2017年8月4日  下午3:11:11
 *
 */
public class ListTest {
	/*
	 * 在Collection的基础上，新增的方法：
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置.如果不存在，返回-1.
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置.如果不存在，返回-1.
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
	
	substring(int from ,int to) /  read(int from,int length)
	
	总结：List中的常用方法：
	增：add(Object obj)
	删：remove(Object obj) / remove(int index)
	改：set(int index, Object ele)
	查：get(int index)
	插：add(int index, Object ele)
	遍历：iterator();增强for;for
	长度：size()
	
	 */
	//遍历
	@Test
	public void test4(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add("AA");
		list.add(new Person("Tom",12));
		list.add(456);
		
		//遍历方式一：
		Iterator iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println("*************");
		//遍历方式二：
		for(Object o : list){
			System.out.println(o);
		}
		System.out.println("*************");
		//遍历方式三：因为List提供索引
		for(int i = 0;i < list.size();i++){
			System.out.println(list.get(i));
		}
		
	}
	
	@Test
	public void test3(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add("AA");
		list.add(new Person("Tom",12));
		list.add(456);
		//修改：
		list.set(1, "BB");
		System.out.println(list);
		
		//获取子集合：
		List subList = list.subList(1, 3);
		System.out.println(subList);
		
	}
	@Test
	public void test2(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add("AA");
		list.add(new Person("Tom",12));
		list.add(456);
		
		int index = list.indexOf(456);
		System.out.println(index);
		
		int lastIndex = list.lastIndexOf(456);
		System.out.println(lastIndex);
		
		
		Object obj = list.remove(2);
		System.out.println(obj);
		System.out.println(list);
		System.out.println(list.get(2));
	}
	
	
	@Test
	public void test1(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add("AA");
		list.add(new Person("Tom",12));
		
		System.out.println(list);
		
		//插入：add(int index, Object ele)
		list.add(1, "BB");
		System.out.println(list);
		
		//插入：addAll(int index, Collection eles)
		List list1 = Arrays.asList(1,2,3);
		list.addAll(2, list1);
//		list.add(2,list1);
		System.out.println(list);
		
		//查询：get(int index)
		System.out.println(list.get(1));
		
	}
}
        5.4 子接口Set
                5.4.1 子接口Set的特点
  • 元素无序 不可重复的集合
    • 元素无序：元素存储的位置不是一个挨着一个是无序的。
    • 不可重复：在这个集合中 不能存储数据相同的 元素
                5.4.2 实现类
  • HashSet:作为主要实现类，来存储无序 不可重复的数据)
  • LinkedHashSet:这个类继承 HashSet 可以按照数据添加顺序实现遍历 底层与HashSet相同 除此之外 还提供了一对索引记录添加的顺序 遍历效率高）
  • TreeSet
                5.4.3 HashSet是如何保证无序 不可重复性的？
  • 哈希算法 和 equals方法
    • 找位置(hashCode方法) 利用哈希算法计算出要添加数据的存储位置
    • 比较（equals方法） 如果这个位置有元素 利用equals方法比较两个元素是否相同 如果相同 添加失败 如果不相同，利用链表链起来
                5.4.4 HashSet如何添加自定义类型的数据？
  • 需要重写hashCode方法 equals方法,HashSet对哈希算法的要求 如果要添加的值一样 计算出的Hash值一定要相同 如果添加的值不一样 尽可能的不相同。对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值
                5.4.4 TreeSet
  • TreeSet实现类（往TreeSet中添加的元素要是同种类型才可以添加，只有同种类型才可以排序 包装类默认已经重写了compareTo方法）
  • 底层存储结构：使用红黑树的方式进行存储的，不同于一维数组、链表
  • TreeSet特别之处：数据是可以按照指定属性进行排序的 但是要保证添加的数据必须是同一个类创建的对象。
                5.4.5 TreeSet怎么排序
  • 自然排序：TreeSet( ) 默认调用所添加数据类型类中重写的compareTo()方法进行排序
    • 自定义类实现Comparable接口
    • 重写compareTo()方法。重写的规则：指明按照哪个属性进行排序

// 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort进行自动排序。
// 实现此接口的对象可以用作有序映射中的键或有 序集合中的元素，无需指定比较器
class Goods implements Comparable { 　　
	private String name; 　
	private double price;
 　	@Override 
 　	//如果当前对象this大 于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回 负整数，如果当前对象this等于形参对象obj，则返回零。 
 　public int compareTo(Object o) { 　
 　　　　if(o instanceof Goods) { 　　　　
 　　　　　　Goods other = (Goods) o; 　　　　
 　　　　　　if (this.price > other.price) {　　　
 　　　　　　　　return 1; 
 　　　　　　　　} else if (this.price < other.price) { 　
 　　　　　　　　return -1;　　　　
 　　　　　　　　} 　　　　　
 　　　　　　　return 0;　　　
 　　　　　　} throw new RuntimeException("输入的数据类型不一致");　
 　　　　} //构造器、getter、setter、toString()方法略
}
  • 定制排序: TreeSet(Comparator comparator)构造器，排序时候调用重写的compare（）方法
  • 怎么实现定制排序？
    • ①创建一个实现 Coparator接口实现类的对象
    • ②需要重写compare(Object,object)指明如何排序
    • ③将 Coparator接口实现类的对象作为参数传递到TreeSet的构造器中，创建TreeSet的对象
    • ④向TreeSet中添加compare()中判断的类的对象即可。
Goods[] all = new Goods[4];
all[0] = new Goods("War and Peace", 100); 
all[1] = new Goods("Childhood", 80); 
all[2] = new Goods("Scarlet and Black", 140); 
all[3] = new Goods("Notre Dame de Paris", 120);
//重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返 回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示 o1小于o2
Arrays.sort(all, new Comparator() {
　　@Override 
　　public int compare(Object o1, Object o2) {
 　　　　Goods g1 = (Goods) o1; 
　　　　 Goods g2 = (Goods) o2;
　　　　 return g1.getName().compareTo(g2.getName());
　　}
});
System.out.println(Arrays.toString(all));
  • 定制排序和自然排序的区别？
    • 自然排序：空参构造器，需要集合中数据类型去实现Comparable 接口 并重写compareTo( )方法,比较固定 不适应随时更改自己需求的排序
    • 定制排序：当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码， 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那 么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排 序的比较。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort）， 从而允许在排序顺序上实现精确控制。
        5.5 集合遍历
           5.5.1迭代器

  • 什么是迭代器(Iterator):提供一种快捷遍历Collection的接口。
    在这里插入图片描述

  • 为什么要集合要提供迭代器？

    • java集合容器的种类有很多种，ArrayList、LinkedList、HashSet…，每种容器都有自己的特点，ArrayList底层维护的是一个数组；LinkedList是链表结构的；HashSet依赖的是哈希表，每种容器都有自己特有的数据结构。 因为容器的内部结构不同，很多时候可能不知道该怎样去遍历一个容器中的元素。所以为了使对容器内元素的操作更为简单，Java引入了迭代器。即我们无需关心该遍历对象的底层结构是什么样子的.只要实现Collection接口的集合,使用迭代器就可以遍历这个对象的内部元素。不同Collection实现类的对迭代器方法的实现也不同。

  • 迭代器的方法

public interface Iterator<E> {
    //是否有下一个元素 
    boolean hasNext();
    //①指针下移② 并将下移后的元素返回。
    E next();
    //从迭代器指向的 collection 中移除迭代器返回的最后一个元素
    void remove();
}
  • 为什么Iterator定义为一个接口而不定义一个类呢？
    • 因为java中集合的种类繁多，不同的集合，iterator中重写的方法也是不同的，所以不能定义为一个类统一种遍历方式。
  • 集合的遍历方式
    • 迭代器
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(new String("AA"));
        coll.add(new Person("Tom",12));
        coll.add(new Person("Tom",12));
        coll.add("BB");
        coll.add(123);
        coll.add(456);
      
        Iterator iterator = coll.iterator(); //返回集合的迭代器 也就是说返回专门遍历集合的接口 这个iterator专门遍历collection 集合 即常见的list 和set集合 
      // 使用iterator的hasNext()、next().推荐使用
        while(iterator.hasNext()){                     //   
            System.out.println(iterator.next());
        }
        
    }
  • 增强for循环:适合遍历Collection集合和数组
    • 当遍历collection集合时 底层原理时使用iterator 进行遍历的。
    • 当遍历数组时底层实现原理就是普通的for循环来实现遍历的。

在这里插入图片描述

// 语法格式：  
  for(数据类型  变量名  :遍历的目标){   //数据类型  变量名:声明一个变量用来接收遍历目标遍历后的元素
  }
for
(Object obj:coll )  {  // 从coll中取出一个元素赋给obj 打印 再取出一个 再赋给再打印，直到取完为止。
System.out.println(obj );

6.Map接口(key-value)

       6.1 Map中数据的特点
  • 存放无序 不可重复的值 键值对
       6.2 为什么Map有这种特点呢？
  • ① 左边key构成的集合是一个set集 只能存放 无序 不可重复 （怎么保证呢 ？ 使用set存储 要求key所在的类重写hashCode()和equals（）方法）
  • ② 右边value 构成collection 集 存放可重复的 无序的 （要去value所在的类重写equals方法）
  • ③ 所以 整个entry构成set集 只能存放 无序 不可重复的
       6.3 Map接口的实现类
  • HashMap :一个特殊的HashSet, 相当所有的 key指向同一个值 ;线程不安全 效率高 可以存储NULL的key和value；
  • linkHashMap 作为HashMap的子类，底层与HashMap的存储方式相同。在添加的同时，还使用双向链表记录了添加的先后顺序，实现按照添加的先后顺序遍历。
  • TreeMap ： 可以按照添加的(k,v)中的k的指定的属性，实现遍历。
  • HashTable ：古老的实现类 线程安全的 效率低 不可以存null的key活value。
  • Properties :键、值都是String类型，常用来处理属性文件
Properties类中常用的方法：

setProperty(String key, String value) 调用 Hashtable 的方法 put，向集合中添加数据
getProperty(String key)：用指定的键在此属性列表中搜索属性。
getProperty(String key, String defaultValue)：用指定的键在属性列表中搜索属性。
load(InputStream inStream)：从输入流中读取属性列表（键和元素对），到集合中
load(Reader reader)：按简单的面向行的格式从输入字符流中读取属性列表（键和元素对），到集合中
  • 注意：HashSet的底层使用的是HashMap 其他的Set也类似。 HashMap的key构成的集合就是HashSet。其他的Map也类似。
       6.4 Map中的抽象方法
添加/修改:put(Object key,Object value);
  删除:remove(Object key)
  查询:
  	get(Object key)  
	containsKey(Object key)  
	containsValue(Object value)
  遍历:遍历key集：keySet()   
  长度:size()
  遍历value集: values()  
  遍历entry集：entrySet()
       6.5 主要实现类HashMap

  • (1)HashMap底层是怎样存放的? （无序 不可重复）
    ①原理：新建一个HashMap的时候就会初始化一个长度为16的Entry数组，根据key 值利用哈希算法计算出 存的位置 如果 hash值相同 调用equals方法 比较key是否相同，若相同 则替换掉原来的位置 ，若不同 形成链表.如果形成链表结构达到8的时候 则使用红黑树替换.（存放于比较与value无关）

  • ② 代码层面：
    HashMap map = new HashMap();//底层创建了长度为16，加载因子为0.75的Entry[]数组
    map.put(k1,v1);
    …
    当添加的元素得到12的时候，进行扩容，默认扩容为原来的2倍，同时将原有的数据copy过去。
    指导意义：开发中，建议使用HashMap( intinitialCapacity)

  • HashMap实现类具体的实现方法有哪些？

 添加/修改:put(Object key,Object value);
  删除:remove(Object key)
  查询:get(Object key)
  长度:size()
  遍历:（遍历出是无序的）
  遍历key集：keySet() （可以用两种遍历方式增强for循环 和 iterator方法）
  遍历value集:   values()  （可以用两种遍历方式增强for循环 和 iterator方法）
  遍历entry集：  entrySet()   （调用 Map 内部类entry（）的key（）方法和value（）方法）
                        keySet()  （利用get（key）得到相应的Value值）
  • 方法测试
package com.atguigu.java;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class MapTest {
	
	/*
	 * 遍历相关的方法：
	 * Set keySet()
	 * Collection values()
	 * Set entrySet()
	 */
	@Test
	public void test4(){
		Map map = new HashMap();
		map.put("Jerry", 1005);
		map.put("Tom", 1001);
		map.put(new Person("HanMeimei",1342), 23);
		
		//1.遍历key集
		Set keySet = map.keySet();
		Iterator iterator = keySet.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println();
		//2.遍历value集
		 //将map所有的value封转到集合中
		Collection values = map.values();
		for(Object obj : values){
			System.out.println(obj);
		}
		System.out.println();
		//3.遍历key-value的方式一：
		Set keySet1 = map.keySet();
		for(Object key : keySet1){
			System.out.println(key + "---->" + map.get(key));
		}
		System.out.println();
		//遍历key-value的方式二：
		Set entrySet = map.entrySet();
		for(Object entry : entrySet){
//			System.out.println(entry);
			Map.Entry e = (Map.Entry)entry;
			System.out.println(e.getKey() + "*****" + e.getValue());
		}
		
		
	}
	
	/*
	 *  Object put(Object key,Object value)
		Object remove(Object key)
		void putAll(Map t)
		void clear()
		Object get(Object key)
		boolean containsKey(Object key)
		boolean containsValue(Object value)
		int size()
		boolean isEmpty()
		boolean equals(Object obj)
		
		总结：添加：put(Object key,Object value)
			删除：remove(Object key)
			修改：put(Object key,Object value)
			查询：get(Object key)
			长度：size()
			遍历：keySet() / values() / entrySet()
	 */
	@Test
	public void test3(){
		Map map = new HashMap();
		map.put("Jerry", 1005);
		map.put("Tom", 1001);
		map.put(new Person("HanMeimei",1342), 23);
		//清空：clear()
//		map.clear();//与map = null不同
		System.out.println(map.size());
		//containsKey(Object key):是否包含指定的key
		System.out.println(map.containsKey("Tom"));
		//containsValue(Object value)：是否包含指定的value
		System.out.println(map.containsValue(1001));
		
		//isEmpty():判断是否非空
		System.out.println(map.isEmpty());
		
		
		
	}
	
	@Test
	public void test2(){
		Map map = new HashMap();
		//1.添加：put(Object key,Object value):将key,value添加到当前map中
		map.put("Jerry", 1005);
		map.put("Tom", 1001);
		map.put(new Person("HanMeimei",1342), 23);
		
		//2.修改：put(Object key,Object value)/replace(K key, V oldValue, V newValue)/replace(K key, V value)
		map.put("Tom", 2001);
		
		//3.删除:remove(Object key)
		Object value = map.remove("Jerry");
		System.out.println(value);
		
		//4.查询：get(Object key) 得到key对应value的值
		Object value1 = map.get("Tom");
		System.out.println("*************");
		System.out.println(value1);
		
		//5.长度：size()
		System.out.println(map.size());
		
		System.out.println(map);
	}

	/*
	 * Map接口框架：
	 * 
	 * Map 
	 * |----HashMap:作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value
	 * 		|----LinkedHashMap: 作为HashMap的子类，底层与HashMap的存储方式相同。在添加的同时，
	 *                         还使用双向链表记录了添加的先后顺序，实现按照添加的先后顺序遍历。
	 * |----TreeMap:可以按照添加的(k,v)中的k的指定的属性，实现遍历。
	 * |-----Hashtable:作为Map的古老实现类；线程安全的，效率低；不可以存储null的key或value
	 * 		|----Properties:键、值都是String类型，常用来处理属性文件
	 * 
	 * 说明：HashSet的底层使用的是HashMap.其他的Set也类似。 HashMap的key构成的集合就是HashSet。其他的Map也类似
	 * 
	 * 面试题：
	 * 1.HashMap的底层实现原理？ （重要）
	 * 
	 * put():
	 * 当向HashMap中添加数据(k1,v1)时，首先根据k1所在类的hashCode()方法，计算k1的哈希值，
	 * 此哈希值就决定了(k1,v2)在HashMap对应的底层数组中的存放位置，如果此位置上没有存放其他数据，
	 * 则此（k1,v1）存储成功。如果此位置上已经存放了(k2,v2).则调用k1所在类的equals()。如果
	 * 返回true，将v1替换原有的v2.如果返回false,（k1,v1）和（k2,v2）使用链表结构进行存储。
	 * （（k1,v2）--->(k2,v2)）.
	 * （jdk8.0以后）如果形成链表结构的数据量得到8的时候，使用红黑树替换链表结构，保证存、取的效率更高。
	 * 
	 *   代码层面：
	 *   HashMap map = new HashMap();//底层创建了长度为16，加载因子为0.75的Entry[]数组
	 *   map.put(k1,v1);
	 *   ...
	 *   当添加的元素得到12的时候，进行扩容，默认扩容为原来的2倍，同时将原有的数据copy过去。
	 * 	 
	 * 	 指导意义：开发中，建议使用HashMap(int initialCapacity).	
	 * 
	 * 2.HashMap和Hashtable的异同？
	 * 	
	 * 
	 * 
	 * 说明：1.map中entry的存放位置/方式，取决于entry中key的存放位置/方式。
	 */

	@Test
	public void test1() {
		Map map = new HashMap();
		map.put("Tom", 13);
		map.put("HanMaimei", 33);
		map.put(new Person("Lilei", 23), 13);
		map.put("Jerry", 34);
		
		map.replace("Tom",13,20);

		System.out.println(map);

	}

	/*
	 * Map:存储双列集合。
	 *  1.存储的是键值对特点的数据：key-value
	 * 2.key中的元素是无序、不可重复的。使用Set进行存储。--->要求key所在的类重写：hashCode()和equals()
	 * 3.value中的元素是无序、可重复的。使用Collection进行存储。---->要求value所在的类重写：equals()
	 * 4.一个key-value构成一个Entry。entry是无序的、不可重复的。使用Set进行存储。--->可以通过key体现。
	 * 
	 */

	
}



package com.atguigu.java;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class MapTest {
	@Test
	public void test() {

		Map map = new HashMap();
		// 添加
		map.put("jerry", 1005);
		map.put("Tom", 1001);
		map.put(new Person("HanMeiMei", 1342), 1001);
		// 修改
		map.put("Tom", "Jerry");
		System.out.println(map);

		// 删除
		// Object val = map.remove("Tom");
		// System.out.println(val);
		// 查询
		Object object = map.get("jerry");
		// 遍历：keySet() / values() / entrySet()
		System.out.println("*************");

		// ①遍历key集合 遍历value结合
		System.out.println("***遍历Key集合***");

		Set keySet = map.keySet();
		Iterator iterator = keySet.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		System.out.println("***遍历Value集合***");
		Collection values = map.values();
		for (Object obj : values) {
			System.out.println(obj);
		}
		System.out.println("***遍历  key Value集合 方式一***");
		// ② 遍历 key-value集
		// 方式一 ：
		Set entrySet = map.entrySet();
		Iterator iterator2 = entrySet.iterator();

		while (iterator2.hasNext()) {
			System.out.println(iterator2.next());

		}
		System.out.println("***遍历  key Value集合 方式二 ***");
		// 方式二
		Set entrySet1 = map.entrySet();
		for (Object obj : entrySet1) {
			System.out.println(obj);
		}
		System.out.println("***遍历  key Value集合 方式三 ***");
		// 方式三
		Set entrySet3 = map.entrySet();
		for (Object obj : entrySet3) {
			Map.Entry entry = (Map.Entry) obj;
			System.out.println(entry.getKey() + "__________" + entry.getValue());
		}
		// 方式四：
		System.out.println("************");
		Set keySet1 = map.keySet();
		for (Object key : keySet1) {
			System.out.println(key +"______"+map.get(key));
		}

	}

}

7 .操作集合的工具类


reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
 swap(List， int， int )：将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src )：将src中的内容复制到 dest中  //正确的复制   List dest = Arrays.asList(new Object[list.size()]);
                                                                      Collections.copy( dest, list);

boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
欧阳喇嘛
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合Collection之Map
蓝影铁哥的博客
07-20 170
java、集合、Collection、Map、HashMap、TreeMap、源码解析
java中的集合 Collection 和 Map
T的专栏
09-14 286
ArrayList和LinkedList都线程不安全，ArrayList优势：随机访问。LinkedList优势：新增和删除。线程安全：HashTable（子类：Properties），synchronizedHashMap。List下三大将：ArrayList和LinkedList,Vector（线程安全）。Map接口：双列数据，保存具有映射关系“key-value对”的集合。Collection 下面两大分支：List和set。两种体系，他们是同一层次，都是java.lang.Java 集合可分为。
java基础之java容器-Collection，Map
最新发布
Hxuening的博客
04-28 1053
java基础 java容器Collecation,Map
Java集合类（Collection、Map）概述
Congee_porridge的博客
12-27 481
首先，要知道Java中的集合不仅仅是指Set系列，而是（包含Set、List、Queue和Map四种体系），是用于存储数量不等的对象。其中，Set代表无序、不可重复的集合；List代表有序、重复的集合；Map则代表具有映射关系的集合；Queue代表一种队列集合；Collection和Map。
Java中Collection集合与Map集合
随风丿雨落的博客
12-06 577
Java中Collection集合与Map集合Collection集合与Map集合常用子集概览一、 Collection类1、List(1)、ArrayList(2)、LinkedList(3)、VectorList总结2、Set(1)、HashSet(2)、LinkedHashSet(3)、TreeSetSet总结二、Map类1、HashMap(1)、LinkedHashMap(2)、ConcurrentHashMap2、TreeMap3、Hashtable Collection集合与Map集合常用子集概
java 集合----Map、Collection
09-02
Java集合框架是编程中不可或缺的一部分，它提供了多种数据结构，如列表(List)、集(Set)以及映射(Map)，便于我们高效地存储、管理和操作数据。本文将深入探讨Map和Collection接口，以及它们的实现类，特别是HashSet和...
java-collection-example
04-13
"java-collection-example"项目旨在展示如何使用Java Collections库的各种组件，包括接口、类和算法。这个库使得开发者能够高效地管理和操作对象集合，无论是简单的数组列表还是复杂的映射结构。 在Java中，集合...
quest-java-collection1
03-17
"quest-java-collection1"可能是一个关于Java集合框架的学习资源或项目，包含有关如何使用和理解Java集合的示例代码或教程。 在Java中，集合框架主要由接口和类组成，如`List`、`Set`、`Queue`和`Map`等接口，以及...
Collection-and-Map.zip_java list map
09-20
关于Map，List，collection集合遍历，泛型等
java-collection-jajal:jajal Java集合
04-20
"java-collection-jajal"很可能是一个项目或者库，专注于Java集合的实现和扩展，旨在提供更高效、易用的工具。虽然没有具体项目的详细描述，但我们可以基于Java集合框架本身来探讨相关知识点。 1. **集合接口**：...
【Java基础】集合Collection、Map详解
weixin_45463540的博客
05-05 625
Collection、Map中的一些常用类和方法 Collection 接口Collections 工具类Iterator 迭代器List 接口ArrayListLinkListListIterator 列表迭代器Set 接口HasSetLinkedHashSetTreeSetMap 接口HashMapTreeMap Collection 接口 boolean add(E e) //添加元素 若确实改变的了集合就返回true,集合没有发生变化就返回false boolean remove
Java-Collection集合和Map集合总结
因特马
05-27 2919
本文欢迎转载，转载前请联系作者，经允许后方可转载。转载后请注明出处，谢谢！ http://blog.csdn.net/colton_null 作者：喝酒不骑马 Colton_Null from CSDN 如果一个程序只有包含固定数量的且其生命周期都是已知的对象，那么这是一个非常简单的程序。 一、引言 我们在编程的时候，有时候在程序运行中需要根据当时的情况去创建对象，在此之前可能不...
Java中Collection和Map
绿箭侠的博客
07-02 488
Collection接口Collection接口继承 Iterable，jdk中有两个子接口，List，Set、Queue；List下有三个实现类Vector、ArrayList、LinkedList；Set下有两个实现类HashSet、LinkedHashSet；Queue下有一个实现类PriorityQueue；...
Java集合零基础必看Part1
HelloWorld
11-07 259
Java集合==Day1 集合可以储存多个数据。无需定义长度，集合会动态增加或减少长度，只能储存引用类型数据 数组也可以储存多个同种数据，需要定义长度，可以储存引用类型和基本数据类型两种 数量固定用后者，反之前者 1.1Collecion接口 Collection主要是List、Set Queue接口的父接口，所以他的方法在子接口中都能调用 常用方法：添加对象、删除对象、清空集合、判断集合是否为空 特点：元素可重复、无序 常用方法 public class Demo2 { publ
Java中Collection和Map体系(Java容器)
ITRenj的博客
07-01 578
Java中Collection和Map体系(Java容器) Java常用容器类继承关系图解 Java容器类简介 Java中容器类主要分为四中体系：List、Set、Queue、Map。 List：代表有序、可重复的集合； Set：代表无序、不可重复的集合； Queue：代表一种队列集合实现； Map：代表具有映射关系的集合。 容器简介 Collection：Collection体系中的基本接口...
java集合基础知识点（Collection和Map）
m0_56639123的博客
07-29 131
集合 java集合分为Collection体系和Map体系 Collection体系：实现collection接口 list：元素有序，且可重复 set：元素无序（每次print可能不一样），不可重复 Map体系：实现map接口 map：k-v数据类型，且kv之间有映射关系 ...
java中collection与map_Java中Collection与Map的一些注意点 | 学步园
weixin_36034883的博客
02-16 129
1.Map 没有继承 Collection 接口。2. Collections是针对集合类的一个帮助类,Collection是一个接口3.Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。4.容器类仅能持有对象引用(指向对象的指针)，而不是将对象信息copy一份至某位置。5.Map中元素，可以将key序列、value序列单独抽取出来。使用keySet()抽...
java常用Collection和Map的继承结构图
qq_35661527的博客
11-06 977
1、常用Collection继承结构图及说明： 1.1 哈希表/散列表数据结构 一、关于Collection常用方法： （ 新建Collection： Collection co1 = new ArrayList();// 多态 Collection co2 = new LinkedList();// 多态 Collection co3 = new Vector();// 多态 ） 1. boolean add(E e) : ..
java Collection 和 Map的区别
05-26
Java中的Collection和Map都是接口，用来存储和操作对象。它们之间的主要区别在于： 1. Collection是一组对象的集合，而Map是键值对的映射。 2. Collection只能通过索引或迭代器遍历元素，而Map可以通过键遍历元素。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值