写在前面

java学习笔记 六——容器

容器Collection

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

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

  Collection接口中定义的方法(List和Set都有):

mark

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底层用双向链表实现的存储。特点:查询效率低,增删效率高,线程不安全

    mark

  • 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);
    }

}

mark

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"));//二分法查找
    }

}

mark

存储表格

使用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();
        }

    }
}

mark

使用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;
    }
}

mark

小结

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


道也者,不可须臾离者也,可离非道也。