java学习笔记 （六）——容器

写在前面

java学习笔记 六——容器

容器Collection

Collection父接口，下面有List和Set子接口。

• List 是有序、可重复的容器。
  1. List中每个元素都有索引标记，可根据索引访问元素
  2. 允许加入重复元素，即元需满足e1.equals(e2);的元素重复加入
• Set 无序，不可重复
  1. Set中元素没有索引，查找只能便利。
  2. 不允许加入重复的元素，当新元素和Set中某个元素通过equals方法对比为true，则不能够加入，null元素也只能最多存入一个

  Collection接口中定义的方法（List和Set都有）：

List中定义的一些方法

• void add(int index,Object element)在指定位置插入元素，并将之后的元素后移一位

   

• Object set(int index,Object element)修改指定位置元素

• Object get(int index)返回指定位置元素

• Object remove(int index)删除指定位置元素，其后的元素前移一位

• int indexOf(Object o)返回第一个匹配元素的索引，如果没有该元素则返回-1

  System.out.println(list.indexOf("B")); // 从头到尾找到第一个"B"

• int lastIndexOf(Object o)返回最后一个匹配元素的索引，如果没有该元素则返回-1

  System.out.println(list.lastIndexOf("B")); //从尾到头找到第一个"B"

List接口常用的实现类：ArrayList,LinkedList,Vector

• ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。（用的较多）

   

• LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全

  

• Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。

使用选择：（ArrayList用的最多）

• 需要线程安全的话，用Vector
• 不考虑线程安全，且查找较多时，使用ArrayList
• 不考虑线程安全，且增加和删除元素较多时用LinkedList

Map接口

  Map存储的是键值对，key-value。通过键来标识，因此键不可以重复。

  Map接口中的实现类有HashMap、TreeMap、HashTable、Properties等。

Map接口中的常用方法

• Object put(Object key,Object value) 存放键值对
• Object get(Object key) 通过键对象查找到值对象
• Object remove(Object key)删除键对象对应的键值对
• boolean containsKey(Object key)Map容器中是否包含键对象所对应的键值对
• boolean containsValue(Object value)Map容器中是否包含值对象对应的键值对
• int size()包含键值对的数量
• boolean isEmpty()Map是否为空
• void putAll(Map map2)将map2的所有键值对存放到map中
• void clear()清空本map对象所有键值对

package cn.xgblack.studyCollection;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * 测试HashMap的使用
 * @author xg
 * @time 2019年4月21日
 */
public class TestMap {
 
    public static void main(String[] args) {
        Map<Integer,String> m1 = new HashMap<>();
        m1.put(1, "one");
        m1.put(2, "two");
        m1.put(3, "three");
 
        System.out.println(m1.get(1));
 
        System.out.println(m1.size());
 
        System.out.println(m1.isEmpty());
 
        System.out.println(m1.containsKey(2));
 
        System.out.println(m1.containsValue("four"));
 
        Map<Integer,String> m2 = new HashMap<>();
        m2.put(4, "四");
        m2.put(5, "五");
 
        m1.putAll(m2);
 
        System.out.println(m1);
 
        //map中健不能重复，（是否重复根据equals方法判断）如果重复，则新的覆盖掉旧的
        m1.put(3, "新的三");
        System.out.println(m1);
    }
 
}
 

HashMap: 线程不安全，效率高。允许key或value为null。

HashTable: 线程安全，效率低。不允许key或value为null。

TreeMap是红黑二叉树实现的

Collections工具类常用方法（并不是Collection接口）

• void sort(List) 对List容器内的元素排序，（升序）
• void shuffle(List) 对List容器内的元素进行随机排列
• void reverse(List) 对List容器内的元素进行逆序排列
• void fill(List, Object) 用一个特定的对象重写整个List容器
• int binarySearch(List, Object) 对于顺序的List容器，采用折半查找的方法查找特定对象

package cn.xgblack.studyCollection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
/**
 * Collections辅助类的使用（非接口）
 * @author xg
 * @time 2019年4月21日
 */
public class TestCollections {
 
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for(int i = 0;i<10;i++) {
            list.add("xg" + i);
        }
        System.out.println(list);
 
        Collections.shuffle(list);//随机排列List中的元素
        System.out.println(list);
 
        Collections.reverse(list);//逆序排列
        System.out.println(list);
 
        Collections.sort(list);//按照递增的方式排序   自定义类的使用：Comparable接口
        System.out.println(list);
 
        System.out.println(Collections.binarySearch(list, "xg1"));//二分法查找
    }
 
}
 

存储表格

使用Map和List

package cn.xgblack.studyCollection;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
/**
 * ORM思想：对象关系映射
 * @author xg
 * @time 2019年4月21日
 */
public class TestStoreData {
    public static void main(String[] args) {
        Map<String,Object> row1 = new HashMap<>();
        row1.put("id", 1001);
        row1.put("name", "张三");
        row1.put("薪水", 20000);
        row1.put("入职日期", "2018.05.04");
 
        Map<String,Object> row2 = new HashMap<>();
        row2.put("id", 1002);
        row2.put("name", "李四");
        row2.put("薪水", 30000);
        row2.put("入职日期", "2019.06.04");
 
        Map<String,Object> row3 = new HashMap<>();
        row3.put("id", 1002);
        row3.put("name", "王五");
        row3.put("薪水", 3000);
        row3.put("入职日期", "2019.01.04");
 
        List<Map<String,Object>> table1 = new ArrayList<>();
        table1.add(row1);
        table1.add(row2);
        table1.add(row3);
 
        for(Map<String,Object> row : table1) {
            Set<String> keyset = row.keySet();
            for(String key:keyset) {
                System.out.print(key + ":" + row.get(key) + "\t");
            }
            System.out.println();
        }
 
    }
}
 

使用javabean和Map或者javabean和List

package cn.xgblack.studyCollection;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
/**
 * 每一行数据使用Javabean对象存储，多行使用Map或List
 * @author xg
 * @time 2019年4月21日
 * @author xg
 * @time 2019年4月21日
 */
public class TestStoreData2 {
 
    public static void main(String[] args) {
        User u1 = new User(1001, "张三", 5000, "2018.05.01");
        User u2 = new User(1002, "李四", 6000, "2019.05.01");
        User u3 = new User(1003, "王五", 8000, "2020.05.01");
 
        List<User> list = new ArrayList<>();
        list.add(u1);
        list.add(u2);
        list.add(u3);
 
        for(User u:list) {
            System.out.println(u);
        }
 
        Map<Integer,User> map = new HashMap<>();
        map.put(1001, u1);
        map.put(1002, u2);
        map.put(1003, u3);
 
        Set<Integer> keyset = map.keySet();;
        for(Integer key:keyset) {
            System.out.println(key + "----" + map.get(key));
        }
    }
}
 
class User{
    private int id;
    private String name;
    private double salary;
    private String hiredate;
 
    //一个完整的javabean。要有get和set方法，以及无参的构造方法
    public User() {
    }
 
 
    public User(int id, String name, double salary, String hiredate) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.hiredate = hiredate;
    }
 
 
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public String getHiredate() {
        return hiredate;
    }
    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
 
    @Override
    public String toString() {
        return "id:" + id + ",name:" + name + ",salary:" + salary + ",hiredate:" + hiredate;
    }
}
 

小结

  容器的难度较之前提高了不少，有很多内容看完就忘记的差不多了，感觉现在回想一下，皮毛都没有学到。