Java-集合

Posted swpCode

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java-集合相关的知识,希望对你有一定的参考价值。

# 1 集合:
* 1、用于存储对象的容器
* 2、集合的长度是可变的 (数组的大小是固定的)
* 3、集合中不可以存储基本数据类型

Collection中常用的方法
1,添加。
boolean add(Object obj):
boolean addAll(Collection coll):

2,删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3,判断:
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
4,获取:
int size():
Iterator iterator():取出元素的方式:迭代器。
该对象必须依赖于具体容器,因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言,具体的实现不重要,只要通过容器获取到该实现的迭代器的对象即可,
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5,其他:
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。

public static void collection(){

        Collection col1 = new ArrayList();
        Collection col2 = new ArrayList();

        col1.add("1");
        col2.add("2");
        col2.add("3");
        System.out.println(col1);
        col1.addAll(col2);
        System.out.println(col1);

//        col1.remove("1");
//        System.out.println(col1);
//        col1.removeAll(col2);
//        System.out.println(col1);

        boolean contain = col1.contains("5");
        System.out.println(contain);

        boolean containsAll = col1.containsAll(col2);
        System.out.println(containsAll);

        boolean empty = col1.isEmpty();
        System.out.println(empty);

        int size = col1.size();
        System.out.println(size);

        Iterator iterator = col1.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            if (next instanceof String && next.equals("1")) {
                iterator.remove();
            } else {
                System.out.println(next);
            }
        }
    }
    

 

Collection
|-- List 有序可重复
|-- Set 无序不重复

 

# 2 、List

List:
|--Vector:内部是数组数据结构,是同步的。增删,查询都很慢!
|--ArrayList:内部是数组数据结构,是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构,是不同步的。增删元素的速度很快。 addFirst等方法

/**
     * List :常见方法
     1,添加
     void add(index,element);
     void add(index,collection);

     2,删除;
     Object remove(index):

     3,修改:
     Object set(index,element);

     4,获取:
     Object get(index);
     int indexOf(object);获取指定元素的索引
     int lastIndexOf(object);
     List subList(from,to);
     *
     */
      
        public static void list(){

        List list = new ArrayList();

        list.add("11");
        list.add("22");
        list.add("33");

        list.add(1,"111");
        System.out.println(list);

        list.remove(1);
        System.out.println(list);

        list.set(1,"222");

        Object o = list.get(1);
        System.out.println(o);


        int i = list.indexOf("33");
        System.out.println(i);

        int i1 = list.lastIndexOf("11");
        System.out.println(i1);

        List list1 = list.subList(0, 1);
        System.out.println(list1);

        // List的遍历方式以及使用,使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查,不会抛出并发修改的异常,
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object o1 = listIterator.next();
            if (o1.equals("11")) {
                // 集合和迭代器同时对元素进行修改,就会产生异常,所以这里不能使用list.add(obj)等方法;
                listIterator.add("44");
//                listIterator.set("111212");
//                listIterator.remove();
            }
        }
        System.out.println(list);

    }

 

# 3、Set

/**
     * Set
     *  Set接口中的方法和Collection一致。
     * |-- HashSet
     * |-- TreeSet 自然排序,如果存放的是自定义对象,使用TreeSet,必须实现Comparable接口,覆盖里面的compareTo方法,添加元素的时候进行比较;如果添加的是字符串
     就不需要覆盖compareTo方法,因为字符串有自己的compareTo方法 , 自定义对象在TreeSet存储时候,如果不覆盖,就会报 java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable异常
     */
    /**
     * HashSet
     * 内部数据结构是哈希表 ,是不同步的。
     *
     如何保证该集合的元素唯一性呢?
     是通过对象的hashCode和equals方法来完成对象唯一性的。
     如果对象的hashCode值不同,那么不用判断equals方法,就直接存储到哈希表中。
     如果对象的hashCode值相同,那么要再次判断对象的equals方法是否为true。
     如果为true,视为相同元素,不存。如果为false,那么视为不同元素,就进行存储。
     记住:如果元素要存储到HashSet集合中,必须覆盖hashCode方法和equals方法。
     一般情况下,如果定义的类会产生很多对象,比如人,学生,书,通常都需要覆盖equals,hashCode方法。
     建立对象判断是否相同的依据。

     如果HashSet不覆盖equal和hashCode方法的话,默认的是使用Object中的equal和hashCode方法
     Object中的equal方法比较地址的,而不是比较内容,如果添加重复的对象,地址不同,就会认为没有重复的对象
     所以比较对象是否相同,必须覆盖equal和hashCode方法
     */
    
    
    public static void hashSet(){
        HashSet set = new HashSet();
        set.add(new Person("pp",21));
        set.add(new Person("zz",22));
        set.add(new Person("tt",23));
        set.add(new Person("pp",21));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Person person = (Person)iterator.next();
            System.out.println(person.getName() + "---------" + person.getAge());
        }


    }
    
    
    public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println("调用了equals方法---------------");
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Person)) {
            throw new ClassCastException("类型转化错误");
        }
        Person person = (Person) obj;
        return this.name.equals(person.name) && this.age == person.age;
    }

    @Override
    public int hashCode() { // 判断人的hash值是否相同
        System.out.println("调用了hashCode方法---------------");
        return this.name.hashCode() + age;
    }
  }

 

# 4、 Map

*
* 可以使用键来查找对象,类似于数组下标。Map.put(key,value)插入数据,Map.get(key)查找数据。键要求唯一。存储方式不是顺序存储,速度快。不必指定Map的尺寸,因为它自己会自动的调整。
*
(1)HashMap使用最快的查找技术,存储无顺序。

(2)TreeMap按照比较结果升序保存。

(3)LinkedHashMap按照插入顺序保存键,同时保留HashMap的查询速度

 

常用方法:
1,添加。
value put(key,value):返回前一个和key关联的值,如果没有返回null.

2,删除。
void clear():清空map集合。
value remove(key):根据指定的key翻出这个键值对。

3,判断。
boolean containsKey(key):
boolean containsValue(value):
boolean isEmpty();

4,获取。
value get(key):通过键获取值,如果没有该键返回null。
当然可以通过返回null,来判断是否包含指定键。
int size(): 获取键值对的个数。

5.特殊方法: Collection<V> values() 包含的值的 Collection 视图。

 

 private static void method1(Map<Integer, String> map) {
        map.put(1, "zhang");
        map.put(2, "wang");
        map.put(3, "li");
        System.out.println(map);

        if (!map.isEmpty()) {
            if (map.containsKey(2)) {
                map.remove(2);
            }
        }

        System.out.println(map);
        System.out.println("size : " + map.size());
        System.out.println(map.get(3));

        Collection values = map.values();
        Iterator iterator = values.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

 

/**
     * 第一种遍历的方法
     * Set<K> keySet():返回键的set集合
     * 取出map中的所有元素。
     * 原理,通过keySet方法获取map中所有的键所在的Set集合,在通过Set的迭代器获取到每一个键,
             在对每一个键通过map集合的get方法获取其对应的值即可。

     */
    private static void method2(Map<Integer, String> map) {
        map.put(8,"zhaoliu");
        map.put(2,"zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");

        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iterator = keySet.iterator();

        while (iterator.hasNext()) {
            Integer key = iterator.next();
            String value = map.get(key);
            System.out.println(value);
        }
    }
/**
     *
     * Set<Map.Entry<K,V>> entrySet()方法:返回一个set集合,里面装的是Map.Entry接口类型的键值对象
     *
     * 第二种遍历map的方式:通过看API:Set<Map.Entry<K,V>> entrySet():Map.Entry<K,V>接口类型,
     * 里面有K getKey() 返回与此项对应的键。 V getValue()  返回与此项对应的值。

     * 思路:通过把map转化为set,进行迭代
     * 通过使用entrySet方法吧键和值的映射关系作为对象,存储到set集合中,这个映射关系的类型为Map.Entry类型
     *
     *
     */
    private static void method3(Map<Integer, String> map) {
        map.put(8,"zhaoliu");
        map.put(2,"zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");

        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println("key : " + entry.getKey());
            System.out.println("value : " + entry.getValue());
        }

    }

 











































以上是关于Java-集合的主要内容,如果未能解决你的问题,请参考以下文章

201621123062《java程序设计》第九周作业总结

Java方法

金蝶handler中 collection 代码片段理解

Alfred常见使用

比较 C# 中的字符串片段并从集合中删除项目

带有红宝石集合/可枚举的酷技巧和富有表现力的片段[关闭]