------------ Set -------------------

有序: 根据添加元素顺序判定, 如果输出的结果和添加元素顺序是一样

无序: 根据添加元素顺序判定,如果输出的结果和添加元素的顺序是不一样的

-----------------------------------------------------------

特点: 无序,不能包含重复元素

去重:

   HashSet 判定对象的hashCode值是相同,如果相同会调用equals比较2个对象的内存地址是否一致

       自定义对象去重都会重写hashCode和equals方法

   TreeSet  添加进去元素必须实现Comparable接口->compareTo()方法实现过程中有自己的实现一套去重算法

Set

-- HasheSet

  - LinkedHashSet

-- SortedSet

  -- TreeSet(排序,并且自动去重)

-- HashSet底层实质是HashMap

-- 进行了HashSet,LinkedHashSet,TreeSet性能比较

HashSet: 无序,元素唯一

LinkedHashSet: 有序,并且保证元素唯一性

TreeSet: 无序,在compareTo方法定义排序算法

----------------- Map ---------------------

Map<key,value>

存储:是以键key,值value方式存储的

key: 无序,不能重复 - > Set集合

value: 可以包含重的值 - > List集合

map = new HashMap();

map.put("字",1192);

map.put(13297086608,"G");

map.put(271314998,"G");

// 通过key获取值

map.get(key);

map.get("字") // 1192

map.get(21314998) // G

// 遍历map集合,只需要key

map.keySet() ==> Set集合

map.values() ==> Collection

/////////////////////////////

for (Object key : map.keySet()) {

Object value = map.get(key);

}

// HashMap和HashTable比较

1、HashMap的key和value都可以为null,而HashTable的key和value都不能为null

2、HashMap是非线程安全,而HashTable是线程安全的

3、HashMap性能比HashTale性能要高,使用率也最多的

set

package com.set.demo.entity;

public class Person implements Comparable {
private Integer id; // 学生编号是唯一
private String name; public Person() { } public Person(Integer id, String name) {
this.id = id;
this.name = name;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
} public int hashCode() {
return this.getName().hashCode() + this.getId().hashCode();
} @Override
public boolean equals(Object obj) {
Person p = null;
if (obj instanceof Person) {
p = (Person) obj;
}
// 学号和姓名都完全一样我就认为是同一个学生
return p.getId().equals(this.getId()) && p.getName().equals(this.getName());
} @Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
} @Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
// 比较的过程返回3个值 >0, =0, <0
// this 指即将添加到集合的元素
// o代表与this比较的元素
Person p = (Person) o;
System.out.println(o+"-----------"+this); return p.getId() - this.getId();
/*return p.getName().hashCode() - this.getName().hashCode() > 0 ? 1 :
(p.getName().hashCode() - this.getName().hashCode()==0 ? 0 : -1);*/
} }
Set方法
package com.set.demo;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set; /**
* Collection
* - Set接口
* 特点: 无序,并且不能包含重复元素
* @author Administrator
*
*/
public class SetDemo {
public static void main(String[] args) {
/*
boolean add(E o);
boolean addAll(Collection c); int size();
boolean contains(Object o);
boolean isEmpty();
void clear();
Iterator<E> iterator(); boolean remove(Object o);
boolean removeAll(Collection c); boolean retainAll(Collection c);
*/ Set set = new HashSet();
set.add("1AAA");
set.add("AAA");
set.add("CCC");
set.add("AAA");
set.add("BBB");
set.add(new Object());
set.add(new Object());
set.addAll(Arrays.asList("AAA","VVV","BBB")); // 判断是否包含CCC字符串对象
System.out.println(set.contains("CCC")); // 获取集合中元素个数
System.out.println("set集合中有:"+set.size()); // 清空集合中的元素
// set.clear(); // 判断集合中是否有元素
System.out.println(set.isEmpty()); // 使用迭代器输出这个集合中的每一个元素
Iterator it = set.iterator(); while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println("\r\n"); // 移除指定的元素
set.remove("1AAA");
// 移除指定集合中的所有元素
set.removeAll(Arrays.asList("AAA","BBB","CCC")); System.out.println(set);
}
}
Set去重
package com.set.demo;

import java.util.HashSet;
import java.util.Set; import com.set.demo.entity.Person; /**
* Set集合接口是无序,不重复
*
* 添加元素的时候判断集合中是否有相同的hashcode值,
* 如果有相同触发equals比较对象中各个属性完全一致认为是同一个对象
* 如果有个属性不同,认为不是同一个对象
* @author Administrator
*
*/
public class SetDemo1 {
public static void main(String[] args) {
Set set = new HashSet();
set.add(new Person(1001, "张三"));
set.add(new Person(1001, "张三"));
set.add(new Person(1002, "李四"));
set.add(new Person(1003, "王五"));
set.add(new Person(1004, "王五1"));
set.add(new Person(1005, "王五2"));
set.add(new Person(1006, "王五3"));
set.add(new Person(1007, "王五4"));
set.add(new Person(1008, "王五5"));
set.add(new Person(1009, "王五6"));
set.add(new Person(1010, "王五7")); System.out.println(set);
}
}
TreeSet排序
package com.set.demo;

import java.util.TreeSet;

import com.set.demo.entity.Person;

/**
* 排序实现类
* @author Administrator
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 必须让其排序的类实现排序算法()
TreeSet treeSet =new TreeSet();
treeSet.add(new Person(1001,"账务"));
treeSet.add(new Person(1010,"账务1"));
treeSet.add(new Person(1005,"账务2"));
treeSet.add(new Person(1002,"账务3")); for (Object obj : treeSet) {
System.out.println(obj);
}
}
}
比较三种set集合子类性能
package com.set.demo.entity;

public class Cat implements Comparable {
private int size; public Cat(int size) {
this.size = size;
} @Override
public int compareTo(Object o) {
Cat cat = (Cat) o;
return this.size - cat.size;
}
}
package com.set.demo;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet; import com.set.demo.entity.Cat; /**
* 比较三种set集合子类性能
* HashSet
* TreeSet
* LinkedHashSet
* @author Administrator
*
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
Random rd = new Random();
testHashSet(rd);
testTreeSet(rd);
testLinkedHashSet(rd);
} private static void testLinkedHashSet(Random rd) {
LinkedHashSet set = new LinkedHashSet();
long startTime = System.nanoTime(); for (int i = 0; i < 1000; i++) { int size = rd.nextInt(1000) + 1;
set.add(new Cat(size));
} long endTime = System.nanoTime();
System.out.println("LinkedHashSet用时:"+(endTime - startTime)); } private static void testTreeSet(Random rd) {
TreeSet set = new TreeSet();
long startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) { int size = rd.nextInt(1000) + 1;
set.add(new Cat(size));
} long endTime = System.nanoTime();
System.out.println("TreeSet用时:"+(endTime - startTime)); } private static void testHashSet(Random rd) {
HashSet set = new HashSet();
long startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) { int size = rd.nextInt(1000) + 1;
set.add(new Cat(size));
} long endTime = System.nanoTime();
System.out.println("HashSet用时:"+(endTime - startTime)); }
}
去重实例
package com.set.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet; import com.set.demo.entity.Person; /**
* 去重实例
* @author Administrator
*
*/
public class DulipulteDemo {
public static void main(String[] args) {
// List集合
List personList = new ArrayList();
// 存储学生
personList.add(new Person(1004,"晴天"));
personList.add(new Person(1004,"晴天"));
personList.add(new Person(1001,"安悟"));
personList.add(new Person(1002,"不忘你"));
personList.add(new Person(1003,"Army"));
personList.add(new Person(1004,"晴天"));
personList.add(new Person(1004,"晴天"));
personList.add(new Person(1004,"晴天"));
personList.add(new Person(1004,"晴天")); // 定义去冲方法
getNewList(personList); System.out.println(personList);
} /**
* 定义去重集合中对象的方法
* @param personList
*/
private static void getNewList(List personList) {
Set set = new TreeSet();
set.addAll(personList);
// 清空原有集合
personList.clear();
// 把set集合中元素添加到list集合中
personList.addAll(set);
}
}
Map  
package com.map.demo;

import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap; /**
* Map集合特点:
* 以键值对方式存储的
* key value
* key1 value1
*
* key不能重复,值可以重复
* HashMap中key和value都可以为null
* @author Administrator
*
*/
public class MapDemo {
public static void main(String[] args) {
// Map集合是以键作为获取value依据
Map map = new HashMap();
map.put("aaa", "aaa对应的值");
map.put("bbb", "bbb的值");
map.put(1, "1key对应值");
map.put(null, null);
map.put("xxxxxx", "王五");
map.put("http://xxxxx/1322443", "java进阶班教室"); System.out.println(map.get(null)); System.out.println(map); System.out.println(map.keySet()); // Set 不能包含重复
System.out.println(map.values()); // List 可以包含重复
System.out.println("------------------------");
// 可以通过key遍历Map集合
for (Object obj : map.keySet()) {
Object key = obj;
Object value = map.get(obj);
System.out.println("key="+key+"-----------value="+value);
} // HashMap和HashTable区别:
//1、 HashMap的键值都可以为null,而HashTable的键和值都不能为null的。
//2、HashMap是非线程安全的,而HashTable是线程安全的。
//3、HashTale的性能比HashMap性能要低。
// 创建线程安全的Map集合
Map map2 = Collections.synchronizedMap(new HashMap()); Hashtable hashTable = new Hashtable();
//hashTable.put("AAA", null);
System.out.println("-------------------------");
SortedMap sortedMap = new TreeMap();
sortedMap.put("AAA", "AAAA");
sortedMap.put("1BBB", "BBBB");
sortedMap.put("aCCC", "CCCC");
sortedMap.put("DDD", "DDDD");
sortedMap.put("EEE", "EEEE"); System.out.println(sortedMap);
}
}

Set集合[HashSet,TreeSet,LinkedHashSet],Map集合[HashMap,HashTable,TreeMap]的更多相关文章

  1. Java 集合系列14之 Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

    概要 学完了Map的全部内容,我们再回头开开Map的框架图. 本章内容包括:第1部分 Map概括第2部分 HashMap和Hashtable异同第3部分 HashMap和WeakHashMap异同 转 ...

  2. Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

    概要 学完了Map的全部内容,我们再回头开开Map的框架图. 本章内容包括:第1部分 Map概括第2部分 HashMap和Hashtable异同第3部分 HashMap和WeakHashMap异同 转 ...

  3. Map总结--HashMap/HashTable/TreeMap/WeakHashMap使用场景分析(转)

    首先看下Map的框架图 1.Map概述 1.Map是键值对映射的抽象接口 2.AbstractMap实现了Map中绝大部分的函数接口,它减少了“Map实现类”的重复编码 3.SortedMap有序的“ ...

  4. hasSet,TreeSet,ArrayList,LinkedList,Vector,HashMap,HashTable,TreeMap利用Iterator进行输出

    基础类,没有重写hashCode()和equals()方法: package niukewang; import java.util.Objects; public class setClass { ...

  5. Java Set 常用集合 HashSet、LinkedHashSet、TreeSet

    Java 中的 Set 是非常常用的数据类型.Set 是无序的 Collection,Java Set 有三个常用的实现类,分别是:HashSet.LinkedHashSet.TreeSet 本文基于 ...

  6. 红黑树规则,TreeSet原理,HashSet特点,什么是哈希值,HashSet底层原理,Map集合特点,Map集合遍历方法

    ==学习目标== 1.能够了解红黑树 2.能够掌握HashSet集合的特点以及使用(特点以及使用,哈希表数据结构) 3.能够掌握Map集合的特点以及使用(特点,常见方法,Map集合的遍历) 4.能够掌 ...

  7. Collections+Iterator 接口 | Map+HashMap+HashTable+TreeMap |

    Collections+Iterator 接口 1. Collections 是一个操作 Set.List 和 Map 等集合的工具类 Collections 中提供了大量方法对集合元素进行排序.查询 ...

  8. 杨晓峰-Java核心技术-9 HashMap Hashtable TreeMap MD

    目录 第9讲 | 对比Hashtable.HashMap.TreeMap有什么不同? 典型回答 考点分析 知识扩展 Map 整体结构 有序 Map HashMap 源码分析 容量.负载因子和树化 精选 ...

  9. Java中的集合HashSet、LinkedHashSet、TreeSet和EnumSet(二)

    Set接口 前面已经简绍过Set集合,它类似于一个罐子,一旦把对象'丢进'Set集合,集合里多个对象之间没有明显的顺序.Set集合于Collection基本上完全一样,它没有提供任何额外的方法. Se ...

随机推荐

  1. 常用几个空格的 Unicode 码

    const SPACE_UNICODE = { 'ensp': '\u2002', 'emsp': '\u2003', 'nbsp': '\u00a0' }

  2. HDU 1257 最少拦截系统【最长上升子序列】

    解题思路:可以转化为求最长上升子序列来做,还是可以用an与按升序排列后的an求LCS来做,为防止超时,用滚动数组优化一下就可以了. 最少拦截系统 Time Limit: 2000/1000 MS (J ...

  3. 脑图工具MindNode"附属节点"是什么意思 图解

    新手会发现在主节点上无论是按Tab子节点还是按Enter附属节点,都是向右延伸,感觉像没区别? 其实不然,从第二个节点开始,你再按 Tab 或者 Enter 就知道区别了. 废话少说,直接上图. 我觉 ...

  4. ajax第二天学习

    post方式发送请求 要首先设置请求头(参数设置为ajax.setRequestHeader("content-type","application/x-www-form ...

  5. 2、Attentive Group Recommendation----注意力集中的群组推荐

    1.摘要: 采用attention和NCF结合解决群组偏好融合的问题. 贡献: 第一个使用神经网络学习融合策略的组推荐. 进一步整合用户-项目交互改进组推荐,减轻冷启动问题. 2.方法: 模型AGRE ...

  6. mmap详解

    共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式, 因为进程可以直接读写内存,而不需要任何 数据的拷贝.对于像管道和消息队列等通信方式,则需要在内核和用户空间进行四次的数据拷贝,而共享内存 ...

  7. Ansible学习记录四:单命令测试

    0.Ansible的group支持all.通配符(*).IP地址 1.查看Ansible的版本 $  ansbile  --version [root@test ~]# ansible --versi ...

  8. C/C++ 浮点数比较问题

    本系列文章由 @YhL_Leo 出品,转载请注明出处. 文章链接: http://blog.csdn.net/yhl_leo/article/details/50255623 Never try to ...

  9. Qt之窗体拖拽、自适应分辨率、自适应大小

    简述 在自定义无边框.标题栏的界面中,需要自己实现最小化.最大化.关闭.窗体背景等功能.最小化.最大化.关闭等按钮设计及功能比较简单,这里就不多做介绍.今天主要介绍一下绘制背景的问题,主要实现自适应屏 ...

  10. 少年 DXH

    少年 DXH 时间限制:1000 ms  |  内存限制:65535 KB 难度:2 描写叙述 大家都知道,DXH 幼时性格怪癖,小朋友都不喜欢和他玩,这样的情况一直到 DXH 的少年时期也没有改变. ...