69期-Java SE-016_集合-2-001-002

### Set集合

Set是Collection的子接口,Set接口采用散列的存储方式,所有元素是无序的,可以存储一组无序且唯一的对象。

实际开发中不能直接实例化Set对象,需要对其实现类进行实例化同时完成相关业务操作,Set常用的实现类HashSet、LinkedHashSet、TreeSet。

#### HashSet

存储一组无序且唯一的对象,这里的无序是指元素的存储顺序和遍历顺序不一致。

```java
import java.util.HashSet;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("Hello");
        System.out.println(hashSet.size());
        hashSet.add("World");
        System.out.println(hashSet.size());
        hashSet.add("Java");
        System.out.println(hashSet.size());
        hashSet.add("Hello");
        System.out.println(hashSet.size());
        Iterator iterator = hashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        hashSet.remove("Hello");
        iterator = hashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
    }
}
```

#### LinkedHashSet

LinkedHashSet是Set的另外一个实现类,可以存储一组有序且唯一的元素,这里的有序是指元素的存储顺序和遍历顺序一致。

```java
import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test2 {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("Hello");
        linkedHashSet.add("World");
        linkedHashSet.add("Java");
        System.out.println(linkedHashSet.size());
        linkedHashSet.add("Hello");
        System.out.println(linkedHashSet.size());
        Iterator iterator = linkedHashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        linkedHashSet.remove("World");
        iterator = linkedHashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
    }
}
```

程序如何判断两个对象是否相等?通过继承自Object类的equals()方法来进行判断的。

LinkedHashSet 判断两个对象是否相等的原理:首先会判断两个对象的hashCode是否相等,什么是hashCode?根据一定的规则奖与对象相关的信息、如内存地址、属性值等,映射成一个数值,这个数值称为散列值,也就是该对象的hashCode。两个不同对象的hashCode可能相等,但是两个hashCode不相等的对象一定不是同一个对象。

集合在判断两个对象是否相等时,会优先比较它们的hashCode,如果不相等,则认为不是同一个对象,如果相等,还不能认为两个对象是相等的,需要通过equals方法进行进一步的验证,如果equals方法返回true,则是同一个对象,否则不是同一个对象,正常添加。

#### TreeSet

TreeSet中保存的元素也是有序的,并且TreeSet的有序和LinkedHashSet的有序有所不同,LinkedHashSet的有序是指元素的存储顺序和遍历顺序是一致的,元素按什么顺序存进去,遍历时就按照什么顺序取出。

TreeSet的有序是指集合内部会自动给所有的元素按照升序进行排列,即无论存入的元素是什么顺序,遍历时都会按照升序进行输出,TreeSet中存储的元素也是唯一的。

```java
import java.util.Iterator;
import java.util.TreeSet;

public class Test4 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(6);
        treeSet.add(2);
        treeSet.add(5);
        treeSet.add(4);
        treeSet.add(1);
        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            int num = (int)iterator.next();
            System.out.println(num);
        }
        System.out.println("**************************");
        treeSet.remove(6);
        iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            int num = (int)iterator.next();
            System.out.println(num);
        }
    }
}
```

```java
import java.util.Iterator;
import java.util.TreeSet;

public class Test5 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new A(1));
        treeSet.add(new A(3));
        treeSet.add(new A(6));
        treeSet.add(new A(2));
        treeSet.add(new A(5));
        treeSet.add(new A(4));
        treeSet.add(new A(1));
        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            A a = (A)iterator.next();
            System.out.println(a);
        }
        System.out.println("*********************");
        treeSet.remove(new A(5));
        iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            A a = (A)iterator.next();
            System.out.println(a);
        }
    }
}

class A implements Comparable{
    private int num;
    public A(int num) {
        this.num = num;
    }
    @Override
    public String toString() {
        return "A [num=" + num + "]";
    }
    /**
     * A.compareTo(B)
     * 返回值:
     * 1表示A大于B
     * 0表示A等于B
     * -1表示A小于B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        A a = (A)o;
        if(this.num>a.num) {
            return 1;
        }else if(this.num == a.num) {
            return 0;
        }else {
            return -1;
        }
    }

}
```

### Map

Set、List接口都是Collection的子接口,Map接口时与Collection完全独立的另外一个体系,它们之间的区别在于Set、List、Collection只能操作单个元素,而Map可以操作一对元素,因为Map中的元素都是以key-value的键值对形式来存储的。

Map接口定义时使用了泛型,并且定义了两个泛型K和V,K表示key,规定了键元素的数据类型,V表示value,规定了值元素的数据类型。

常用方法:

- int size()                                    获取集合长度
- boolean isEmpty()                                                       判断集合是否为空
- boolean containsKey(Object key)                             判断集合中是否存在某个key值
- boolean containsValue(Object value)                      判断集合中是否存在某个value值
- V get(Object key)                                                         获取集合中key对应的value值
- V put(K key,V value)                                                     向集合中存入一组key-value的元素
- V remove(Object key)                                                  删除集合中key对应的value值
- void putAll(Map map)                                                 向集合中添加另外一个Map集合
- void clear()                                                                    清空集合
- Set<K> keySet()                                                            取出集合中所有的key,返回一个Set集合
- Collection<V> values()                                                取出集合中所有的value,返回一个Collection集合
- Set<Map,Entry<K,V>> entrySet()                               将Map对象转为Set对象
- int hashCode()                                                              获取集合的散列值
- boolean equals(Object o)                                           判断两个集合是否相等

### Map接口的实现类

- HashMap:存储一组无序、key不可重复,但value可重复的元素。
- Hashtable:存储一组无序、key不可重复、但value可重复的元素。
- TreeMap:存储一组有序、key不可重复、但value可重复的元素,可以按照key值进行排序。

HashMap的使用

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

public class Test6 {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap();
        hashMap.put("h", "Hello");
        hashMap.put("w","World");
        hashMap.put("j","Java");
        hashMap.put("s", "JavaSE");
        hashMap.put("m", "JavaME");
        hashMap.put("e", "JavaEE");
        System.out.println(hashMap);
        hashMap.remove("e");
        System.out.println(hashMap);
        hashMap.put("m", "Model");
        System.out.println(hashMap);
        hashMap.put("m2", "Model");
        System.out.println(hashMap);
        if(hashMap.containsKey("a")) {
            System.out.println("集合中存在值为a的key");
        }else {
            System.out.println("集合中不存在值为a的key");
        }
        if(hashMap.containsValue("Java")) {
            System.out.println("集合中存在值为Java的value");
        }else {
            System.out.println("集合中不存在值为Java的value");
        }
        Set keys = hashMap.keySet();
        Iterator iterator = keys.iterator();
        while(iterator.hasNext()) {
            String key = (String)iterator.next();
            System.out.println(key);
        }
        System.out.println("******************************");
        Collection<String> values = hashMap.values();
        Iterator iter = values.iterator();
        while(iter.hasNext()) {
            String value = (String) iter.next();
            System.out.println(value);
        }
        System.out.println("*********************************");
        Set keys2 = hashMap.keySet();
        Iterator iter2 = keys2.iterator();
        while(iter2.hasNext()) {
            String key = (String) iter2.next();
            String value = hashMap.get(key);
            System.out.println(key+"---"+value);
        }
    }
}
```

Hashtable的使用与HashMap基本一致,Hashtable是早期的实现类,与HashMap的区别是Hashtable是线程安全的,但是性能较低,HashMap是非线程安全,但是性能较高,从实际开发角度讲,HashMap的使用频率更高。

```java
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;

public class Test7 {
    public static void main(String[] args) {
        Hashtable<String,String> hashtable = new Hashtable();
        hashtable.put("h", "hello");
        hashtable.put("w", "world");
        hashtable.put("j", "Java");
        hashtable.put("s", "JavaSE");
        hashtable.put("m", "JavaME");
        hashtable.put("e", "JavaEE");
        System.out.println(hashtable);
        hashtable.remove("e");
        System.out.println(hashtable);
        hashtable.put("m", "Model");
        System.out.println(hashtable);
        System.out.println(hashtable.containsKey("a"));
        System.out.println(hashtable.containsValue("Java"));
        Collection<String> values = hashtable.values();
        Iterator iterator = values.iterator();
        while(iterator.hasNext()) {
            String value = (String)iterator.next();
            System.out.println(value);
        }
        System.out.println("*********");
        Set keys = hashtable.keySet();
        Iterator iter = keys.iterator();
        while(iter.hasNext()) {
            String key = (String)iter.next();
            String value = hashtable.get(key);
            System.out.println(key+"---"+value);
        }
    }
}
```

Test.java

import java.util.HashSet;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("Hello");
        System.out.println(hashSet.size());
        hashSet.add("World");
        System.out.println(hashSet.size());
        hashSet.add("Java");
        System.out.println(hashSet.size());
        hashSet.add("Hello");
        System.out.println(hashSet.size());
        Iterator iterator = hashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        hashSet.remove("Hello");
        iterator = hashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
    }
}

Test2.java

import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test2 {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("Hello");
        linkedHashSet.add("World");
        linkedHashSet.add("Java");
        System.out.println(linkedHashSet.size());
        linkedHashSet.add("Hello");
        System.out.println(linkedHashSet.size());
        Iterator iterator = linkedHashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        linkedHashSet.remove("World");
        iterator = linkedHashSet.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
    }
}

Test3.java

import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test3 {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new A(1));
        linkedHashSet.add(new A(1));
        Iterator iterator = linkedHashSet.iterator();
        while(iterator.hasNext()) {
            A a = (A)iterator.next();
            System.out.println(a);
        }
    }
}

//class A{
//    private int num;
//    public A(int num) {
//        this.num = num;
//    }
//    @Override
//    public String toString() {
//        return "A [num=" + num + "]";
//    }
//    @Override
//    public int hashCode() {
//        // TODO Auto-generated method stub
//        return 1;
//    }
//    @Override
//    public boolean equals(Object obj) {
//        // TODO Auto-generated method stub
//        return true;
//    }
//}

Test4.java

import java.util.Iterator;
import java.util.TreeSet;

public class Test4 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(1);
        treeSet.add(3);
        treeSet.add(6);
        treeSet.add(2);
        treeSet.add(5);
        treeSet.add(4);
        treeSet.add(1);
        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            int num = (int)iterator.next();
            System.out.println(num);
        }
        System.out.println("**************************");
        treeSet.remove(6);
        iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            int num = (int)iterator.next();
            System.out.println(num);
        }
    }
}

Test5.java

import java.util.Iterator;
import java.util.TreeSet;

public class Test5 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new A(1));
        treeSet.add(new A(3));
        treeSet.add(new A(6));
        treeSet.add(new A(2));
        treeSet.add(new A(5));
        treeSet.add(new A(4));
        treeSet.add(new A(1));
        Iterator iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            A a = (A)iterator.next();
            System.out.println(a);
        }
        System.out.println("*********************");
        treeSet.remove(new A(5));
        iterator = treeSet.iterator();
        while(iterator.hasNext()) {
            A a = (A)iterator.next();
            System.out.println(a);
        }
    }
}

class A implements Comparable{
    private int num;
    public A(int num) {
        this.num = num;
    }
    @Override
    public String toString() {
        return "A [num=" + num + "]";
    }
    /**
     * A.compareTo(B)
     * 返回值:
     * 1表示A大于B
     * 0表示A等于B
     * -1表示A小于B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        A a = (A)o;
        if(this.num>a.num) {
            return 1;
        }else if(this.num == a.num) {
            return 0;
        }else {
            return -1;
        }
    }

}

Test6.java

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

public class Test6 {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap();
        hashMap.put("h", "Hello");
        hashMap.put("w","World");
        hashMap.put("j","Java");
        hashMap.put("s", "JavaSE");
        hashMap.put("m", "JavaME");
        hashMap.put("e", "JavaEE");
        System.out.println(hashMap);
        hashMap.remove("e");
        System.out.println(hashMap);
        hashMap.put("m", "Model");
        System.out.println(hashMap);
        hashMap.put("m2", "Model");
        System.out.println(hashMap);
        if(hashMap.containsKey("a")) {
            System.out.println("集合中存在值为a的key");
        }else {
            System.out.println("集合中不存在值为a的key");
        }
        if(hashMap.containsValue("Java")) {
            System.out.println("集合中存在值为Java的value");
        }else {
            System.out.println("集合中不存在值为Java的value");
        }
        Set keys = hashMap.keySet();
        Iterator iterator = keys.iterator();
        while(iterator.hasNext()) {
            String key = (String)iterator.next();
            System.out.println(key);
        }
        System.out.println("******************************");
        Collection<String> values = hashMap.values();
        Iterator iter = values.iterator();
        while(iter.hasNext()) {
            String value = (String) iter.next();
            System.out.println(value);
        }
        System.out.println("*********************************");
        Set keys2 = hashMap.keySet();
        Iterator iter2 = keys2.iterator();
        while(iter2.hasNext()) {
            String key = (String) iter2.next();
            String value = hashMap.get(key);
            System.out.println(key+"---"+value);
        }
    }
}

Test7.java

import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;

public class Test7 {
    public static void main(String[] args) {
        Hashtable<String,String> hashtable = new Hashtable();
        hashtable.put("h", "hello");
        hashtable.put("w", "world");
        hashtable.put("j", "Java");
        hashtable.put("s", "JavaSE");
        hashtable.put("m", "JavaME");
        hashtable.put("e", "JavaEE");
        System.out.println(hashtable);
        hashtable.remove("e");
        System.out.println(hashtable);
        hashtable.put("m", "Model");
        System.out.println(hashtable);
        System.out.println(hashtable.containsKey("a"));
        System.out.println(hashtable.containsValue("Java"));
        Collection<String> values = hashtable.values();
        Iterator iterator = values.iterator();
        while(iterator.hasNext()) {
            String value = (String)iterator.next();
            System.out.println(value);
        }
        System.out.println("*********");
        Set keys = hashtable.keySet();
        Iterator iter = keys.iterator();
        while(iter.hasNext()) {
            String key = (String)iter.next();
            String value = hashtable.get(key);
            System.out.println(key+"---"+value);
        }
    }
}

原文地址:https://www.cnblogs.com/HiJackykun/p/11172960.html

时间: 2024-10-16 04:45:18

69期-Java SE-016_集合-2-001-002的相关文章

69期-Java SE-015_集合-1-001-002

### Collection 接口,一个Collection存储一组无序.不唯一的对象,一般不会直接使用该接口. Collection 常用方法 - int size() 获取集合的长度 - boolean isEmpty() 判断集合是否为空 - boolean contains(Object o) 判断集合中是否存在某个对象 - Iterator<E> itertor() 实例化Iterator接口,遍历集合 - Object[] toArray() 将集合转换为一个Object类型的数组

69期-Java SE-035_MySQL-6 存储过程、SQL练习 -doing

### 存储过程 存储过程是一组为了完成特定功能的 SQL 语句集合,经过编译后存储在数据库中,用户通过指定存储过程的名称以及参数来执行相应的存储过程. 一次编写,多次调用,避免开发人员重复编写相同的 SQL 语句,存储过程是在数据库中存储和执行的,可以减少客户端和服务端之间的数据传输,从而提高效率. ### 优点 - 模块化的程序设计,只需要创建一次存储过程,以后就可以在程序中调用该存储过程任意次. - 执行速度更快,如果某个操作需要执行大量的 SQL 语句或者需要重复执行 SQL 语句,存储

69期-Java SE-040_JDBC-4

C3P0 的使用 1.c3p0-config.xml 名称不能自定义 ```xml <c3p0-config> <named-config name="testc3p0"> <property name="user">root</property> <property name="password">root</property> <property name=&quo

69期-Java SE-031_MySQL-001-002 创建表、MySQL数据类型、数据的管理(数据库结构、数据表、数据)、SQL 函数

### 创建表 1.创建数据库 ```sql create database mstest default character set utf8 collate utf8_general_ci ``` 2.创建数据表 ```sql create table user( id int, name varchar(11) ) ``` Java 数据类型:基本数据类型 byte short int long double float boolean char ? 引用类型 MySQL 数据类型 - 整

69期-Java SE-002_变量、运算符-001-002

- 声明变量的数据类型和变量名. - 给内存空间赋值,该值就是变量值. - 通过变量名使用变量. ```java public class Hello { public static void main(String[] args) { //1.开辟内存空间,定义变量名 int num1; //2.赋值 num1 = 10; //3.使用变量 System.out.println(num1); } } ``` ```java public class Hello { public static

69期-Java SE-003_流程控制、循环-001-002

### 位运算符 十进制和二进制的转换. - 十进制转二进制:目标数除以二,如果能除尽,则该位计作零,如果除不尽,则该位计作一,再对商继续除以二,以此类推,直到商为零,然后将每一位的结果进行反序组合就是对应的二进制结果,10 转为二进制 1010,17 转为二进制 10001 - 二进制转十进制:从目标数最右侧算起,本位的数值乘以本位的权重,权重就是2的第几位的位数减一次方,如果第1位就是2的(1-1)次方,第2位就是2的(2-1)次方,第3位就是2的(3-1)次方…,将每一位的数值和本位权重相

69期-Java SE-004_循环、数组-001-002

Hello.java import java.util.Scanner; public class Hello { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String str = "yes"; int num; while(str.equals("yes")) { System.out.print("请输入学生编号:")

69期-Java SE-036_MySQL-7 SQL练习 -doing

第一道: 现有图书管理数据库的三个关系模式,他们的字段分别如下: 图书表:总编号, 分类号, 书名, 作者, 出版单位, 单价 读者表:借书证号, 单位, 姓名, 性别, 职称, 地址 借阅表:借书证号, 总编号, 借书日期 以上表对应的字段明细如下: book : b_no ,b_type ,b_name , b_author ,b_publish ,b_price reader : r_no , r_unit , r_name ,r_sex ,r_pro ,r_address borrow

69期-Java SE-005_二维数组、综合练习-001-002

Test.java public class Test { public static void main(String[] args) { int[] array = {73,80,62,93,96,87}; //求最大值 int max = array[0]; for(int i=1;i<array.length;i++) { if(array[i]>max) { max = array[i]; } } System.out.println("数组中的最大值是"+max