———-Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———-
第一个类 Set类
一、摘要。
1、Set是一个不包含重复元素的Collection。
2、Set允许包含null元素，但是只允许同一个Set集合中只包含有一个null元素。
3、Set是Collection接口的一个子接口。
4、Set的两个实现类HashSet和TreeSet.
5、Set接口的定义如下：
6、Set集合的功能和Collection是一致的。
public interface Set<E> extends Collection<E>
一、HashSet类。
1、概述。
1）此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
2）可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。
2、构造函数摘要。
1）HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16。
2）HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。
示例一：
package 泛型;
import java.util.HashSet;
import java.util.Iterator;
/**
*
* @author ZHANGYU
* |--Set:元素是无序的（存入和取出的顺序不一定一致），元素不可以重复，线程是非同步的
* |--HashSet:底层数据结构是哈希表
* HashSet是如何保证元素的唯一性呢？
* 是通过元素的两个方法HashCode和equals来完成
* 如果元素的HashCode相同，才会判断equals是否为true,
* 如果元素的HashCode不同，不会调用equals
* 注意：判断元素是否存在，以及删除等操作，依赖的方法是hashCode和equals方法
* |--TreeSet：可以对set集合中的元素自然排序
* 底层数据结构是二叉树
* 保证元素唯一性的一句：
* compareTo方法return
* TreeSet排序的第一种方式：让元素自身具有比较性
* 元素需要实现comparable接口，实现compareTo方法
* 这种方式称为元素的自然顺序，也成为默认顺序
*
* TreeSet排序的第二种方式：
* 当元素没有比较性时，或具备的比较性不是所需要的
* 这时候就需要让集合自身具有比较性
* 在集合初始化时就有了比较方式
* Set功能和Collection是一致的。
*/
public class setDemo {
public static void main(String[] args){
HashSet hs=new HashSet();
hs.add("1");
hs.add("2");
hs.add("3");
hs.add("3");
Iterator it=hs.iterator();
while(it.hasNext()){
sop(it.next());
}
}
private static void sop(Object obj) {
// TODO Auto-generated method stub
System.out.println(obj);
}
}
示例二：
package 泛型;
/**
* 保证集合中元素的唯一性。
* 需求：
* 1、向集合中存储对象元素。
* 2、姓名，和年龄相同视为同一个元素。
*
*/
import java.util.HashSet;
import java.util.Iterator;
/*
* 通过覆写hashCode函数和equals函数。
* 来保证元素的唯一性。
*/
class person1{
private String name;
private int age;
public person1(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return name;
}
public int getAge()
{
return age;
}
//覆盖其hashCode函数
public int hashCode(){
return this.name.hashCode()+age*27;
}
public boolean equals(Object obj){
if(!(obj instanceof person1))
return false;
person1 p=(person1)obj;
return this.name.equals(p.getName())&&this.age==p.getAge();
}
}
public class setDemo1 {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args){
//建立集合对象
HashSet hs=new HashSet();
// 向集合中添加元素
hs.add(new person1("1",23));
hs.add(new person1("2",25));
hs.add(new person1("4",45));
hs.add(new person1("4",45));
hs.add(new person1("6",24));
hs.add(new person1("6",24));
//遍历元素。
Iterator it=hs.iterator();
while(it.hasNext()){
person1 p=(person1) it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
二、TreeSet类。
1、概述。
1）此类实现了Set接口和SortedSet接口。
2）此类使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造。
2、构造函数概述。
1）TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
2）TreeSet(Collection<? extends E> c) 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
3）TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
示例：
package 泛型;
/*
需求
1、存储对象元素
2、给其赋予比较性，使其进行比较。
*/
import java.util.Iterator;
import java.util.TreeSet;
class Student implements Comparable{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
//覆写compareTo函数，按照指定的比较性进行排序
public int compareTo(Object obj) {
// TODO Auto-generated method stub
if(!(obj instanceof Student))
throw new RuntimeException("不是学生类");
Student s=(Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
return this.name.compareTo(s.getName());
return -1;
}
}
public class TreeSetDemo1 {
public static void main(String[] args){
TreeSet ts=new TreeSet();
ts.add(new Student("abc",23));
ts.add(new Student("abg",25));
ts.add(new Student("adc",32));
ts.add(new Student("sbc",43));
ts.add(new Student("afc",43));
Iterator it=ts.iterator();
while(it.hasNext()){
Student s=(Student)it.next();
System.out.println(s.getName()+"::"+s.getAge());
}
}
}
第二个类 Map类
一、概述。
1、Map<K,V>可用于保存具有映射关系的数据。
2、一个映射不能包含重复的键；每个键最多只能映射到一个值。
3、Map<K,V>接口的实现如下：
public interface Map<K,V>二、Map集合的简介。
1、方法。
1） 存
* V put(K key, V value) 添加元素如果存入相同的键，他会覆盖先存入的值，并且返回被覆盖的那个值
void putAll(Map<? extends K,? extends V> m) 2 ）删。
void clear()
remove(Object key)
3） 判断。
containsKey(Object key)
containsValue(Object value)
isEmpty()
4 ）获取。
get(Object key ）
size()
values()
entrySet()
keySet()
2、Map的子类。
Map
|—Hashtable:底层是哈希表数据结构，不可以存入null键和null值。该集合线程同步，jdk1.0 效率低。
|—HashMap:底层是哈希表数据结构，可以存入null键和null值。该集合线程不同步，jdk1.2 效率高。
|—TreeMap:底层是二叉树数据结构，线程不同步，可以给集合中的键进行排序。
和Set很像，其实set底层就是使用了map集合。
示例一：
package 泛型;
/*
Map集合的一些基本方法演示。
*/
import java.util.HashMap;
import java.util.Map;
public class MapTest1 {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi1");
map.put("03", "wangwu");
map.put("04", "zhaoliu");
System.out.println("1"+map);
System.out.println("2"+map.get("01"));
System.out.println("3"+map.remove("01"));
System.out.println("4"+map);
System.out.println("5"+map.containsKey("01"));
System.out.println("6"+map.containsValue("lisi"));
System.out.println("7"+map);
System.out.println("8"+map.put("02", "lisi"));
System.out.println("9"+map);
}
}
HashMap类
一、概述。
1、此类实现了Map集合，对元素的添加和删除具有较高的效率。
2、此类提供了所有可选的映射操作，并且允许使用null值和null键，但必须保证键的唯一性。
3、此类是非同步的类，同时也不保证映射顺序。
二、构造函数摘要。
1、HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
2、HashMap(Map<? extends K,? extends V> m)构造一个映射关系与指定 Map 相同的新 HashMap。
示例一：
package 泛型;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*取出演示：
* entrySet()
*
* keySet()：返回map集合存入到set集合中，通过set迭代器取出所有的键，之后通过map的get方法获取值
*/
public class MapTest2 {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi1");
map.put("03", "wangwu");
map.put("04", "zhaoliu");
//第一种
// Set<String> key=map.keySet();
// Iterator<String> it=key.iterator();
// while(it.hasNext()){
// String obj=it.next();
// System.out.println(obj+"::"+map.get(obj));
// }
//第二种
Set<Entry<String,String>> en=map.entrySet();
Iterator<Entry<String,String>> it=en.iterator();
while(it.hasNext()){
Entry<String,String> e=it.next();
System.out.println(e.getKey()+"::"+e.getValue());
}
}
}
示例二：
package 泛型;
/*每个学生都有对应的归属地，
* 学生：student11 地址String
* 学生属性：姓名、 年龄
* 注意：姓名和年龄相同视为同一个学生
* 保证学生的唯一性
*
*
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
class student11 implements Comparable<student11>{
private String name=null;
private int age=0;
public student11(String name, int age) {
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int hashCode(){
return name.hashCode()+age*27;
}
public boolean equals(Object obj){
if(!( obj instanceof student11))
return false;
student11 s=(student11)obj;
return this.name.equals(s)&&this.getAge()==age;
}
@Override
public int compareTo(student11 s) {
// TODO Auto-generated method stub
int num=new Integer(this.age).compareTo(new Integer(s.getAge()));
if(num==0)
return this.name.compareTo(s.getName());
return num;
}
public String toString(){
return this.name+"::"+this.age;
}
}
public class MapTest3 {
public static void main(String[] args){
HashMap<student11,String> map=new HashMap<student11,String>();
map.put(new student11("dzhangsan",21), "beijing");
map.put(new student11("slisi",23), "tianjin");
map.put(new student11("xwangwu",25), "shandong");
map.put(new student11("vzhaoliu",26), "shanghai");
map.put(new student11("wancai",27), "anhui");
//第一种取出方式。
Set<student11> keyset=map.keySet();
Iterator<student11> it=keyset.iterator();
while(it.hasNext()){
student11 s=it.next();
System.out.println(s.getName()+"::"+s.getAge()+"::"+map.get(s));
}
//第二种取出方式
System.out.println();
Set<Entry<student11,String>> entry=map.entrySet();
Iterator<Entry<student11,String>> it1=entry.iterator();
while(it1.hasNext()){
Entry<student11,String> en=it1.next();
student11 s=en.getKey();
String add=en.getValue();
System.out.println(s+"::"+add);
}
}
}
TreeMap类
一、概述。
该类映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
二、构造函数摘要。
1、TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
2、TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
3、TreeMap(Map<? extends K,? extends V> m) 构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。
示例一：
package 泛型;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
class stuNameComparator implements Comparator<student11>{
public stuNameComparator(){
}
//根据姓名进行排序。
public int compare(student11 o1, student11 o2) {
// TODO Auto-generated method stub
int num=o1.getName().compareTo(o2.getName());
if(num==0)
return new Integer(o1.getAge()).compareTo(o2.getAge());
return num;
}
}
public class TreeMapTest1 {
public static void main(String[] args){
TreeMap<student11,String> tm=new TreeMap<student11,String>(new stuNameComparator());
tm.put(new student11("zhangsan",21), "beijing");
tm.put(new student11("lisi",23), "tianjin");
tm.put(new student11("wangwu",56), "shandong");
tm.put(new student11("zhaoliu",26), "shanghai");
tm.put(new student11("wancai",73), "anhui");
tm.put(new student11("a",75), "anhui");
Set<Entry<student11,String>> entry=tm.entrySet();
Iterator<Entry<student11,String>> it=entry.iterator();
while(it.hasNext()){
Entry<student11, String> s=it.next();
System.out.println(s.getKey()+":"+s.getValue());
}
}
}
示例二：
package 泛型;
/*
* 1.练习
* “adcdswe”获取字符串中的字母，并且算出字母出现的次数
* a(1)
* d(1)
*
*
* */
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest2 {
public static void main(String[] args){
charCount("abcedaadadasdsddsdgdsdf");
}
public static void charCount(String str){
char[] ch=str.toCharArray();
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
for(int i=0;i<ch.length;i++){
boolean flage=tm.containsKey(ch[i]);
if(flage==true){
int count=tm.get(ch[i]);
count++;
tm.put(ch[i], count);
}
else{
tm.put(ch[i], 1);
}
}
Set<Entry<Character,Integer>> entry=tm.entrySet();
Iterator<Entry<Character,Integer>> it=entry.iterator();
while(it.hasNext()){
Entry<Character,Integer> en=it.next();
System.out.println(en.getKey()+"("+en.getValue()+")");
}
}
}
———-Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———-