zoukankan      html  css  js  c++  java
  • 集合

             

    collection集合的常用功能

    Collection<String> coll = new ArrayList<>();
    System.out.println(coll);
    //添加数据,成功返回true,否则返回false
    coll.add("赵四");
    coll.add("刘恩");
    coll.add("成龙");
    System.out.println(coll);
    //删除数据,成功返回true,否则返回false
    coll.remove("赵四");
    System.out.println(coll);
    //判断是否包含,包含返回true,否则返回false
    coll.contains("成龙");
    //判断当前集合是否为空,集合为空返回true,集合不为空返回false
    coll.isEmpty();
    //返回集合中的元素个数
    System.out.println(coll.size());
    //把集合中的元素存储到数组中
    Object[] arr = coll.toArray();
    /*
    for (Object o : arr) {
         System.out.println(o);
    }*/
    for (int i=0;i<arr.length;i++){
          System.out.println(arr[i]);
    }
    //清空集合
    coll.clear();
    System.out.println(coll);

    迭代器的实现

    
    
         //创建集合对象
    Collection<String> coll = new ArrayList<>();
    //往集合中添加元素
    coll.add("姚明");
    coll.add("科比");
    coll.add("麦迪");
    coll.add("詹姆斯");


    Iterator<String> it = coll.iterator();
    //使用iterator接口中的方法hasnext判断还有没有下一个元素
    //方法一
    while (it.hasNext()){
    String next = it.next();
    System.out.println(next);
    }
    /*
    //方法二
    for (Iterator<String> it2 = coll.iterator();it2.hasNext();){
    String next = it2.next();
    System.out.println(next);
    }

    //方法三
    boolean b = it.hasNext();
    System.out.println(b);
    String next = it.next();
    System.out.println(next);

    b = it.hasNext();
    System.out.println(b);
    next = it.next();
    System.out.println(next);

    b = it.hasNext();
    System.out.println(b);
    next = it.next();
    System.out.println(next);

    b = it.hasNext();
    System.out.println(b);
    next = it.next();
    System.out.println(next);

    b = it.hasNext(); //没有下一个值返回false
    System.out.println(b);
    next = it.next(); //取不到下一个值会报错
    System.out.println(next);
    */

    增强for循环

    /*格式for(集合/数组的数据类型 变量名:集合名/数组名字){
    sout(变量名)
    }
    */

    //使用增强for循环遍历集合
    ArrayList<String> list = new ArrayList<>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    for (String s:list){
    System.out.println(s);
    }
    //使用增强for循环遍历数组
    int[] arr = {1,2,3,4,5};
    for (int i : arr) {
    System.out.println(i);
    }
    }

     泛型的概念:是一种未知的数据类型,当我们不知道用什么数据类型的时候,可以使用泛型,泛型

           可以看成是一个变量,用来接收数据类型;创建集合的时候,就确定了数据类型。

    创建集合使用泛型:

              优势:1.避免类型转换的麻烦,存储是什么类型,取出是什么类型

                 2.把运行期异常(运行之后报错),提升到编译器(写代码报错)

              弊端:1.泛型是什么类型,只能存储什么类型的数据

    创建集合不使用泛型:

              优势:集合不使用泛型,默认就是object类型,可以存储任意类型的数据

              弊端:不安全,会引发异常

    定义和使用泛型的类:

    定义和使用泛型的方法:

    定义和使用泛型的接口:

    泛型的通配符?

    数据结构

        栈:先进后出

        队列:先进先出

        链表:查询慢:每次查询元素,都必须从头开始查询

           增删快:链表结构,增加和删除元素,对链表的整体结构没有影响,所以增删快

           单向链表:链表中只有一条链子,不能保证元素的顺序(存储元素和取出元素的顺序有可能不一样)

           双向链表:链表中有两个链子,有一条链子是专门记录元素的顺序,是一个有序的集合

         红黑树:查询速度非常快

    list集合特点

          1.有序集合,存储元素和取出元素的顺序是一致的

          2.有索引,包含了一些带索引的方法

          3.允许存储重复元素

    //创建一个list集合多态
    List<String> list = new ArrayList<>();
    //使用add方法添加元素
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("a");
    //打印集合
    System.out.println(list);
    //指定索引处添加元素
    list.add(2,"你好");
    System.out.println(list);
    //移除指定索引元素,返回被移除的元素
    String remove = list.remove(2);
    System.out.println(remove);
    System.out.println(list);
    //用指定元素替换集合中的指定元素,返回值的更新前的元素
    String a = list.set(3, "A");
    System.out.println(a);
    System.out.println(list);
    //普通for循环遍历
    for (int i = 0;i<list.size();i++){
    String s = list.get(i);
    System.out.println(s);
    }
    System.out.println("-------------------");
    //使用迭代器
    Iterator<String> it = list.iterator();
    while (it.hasNext()){
    String next = it.next();
    System.out.println(next);
    }
    System.out.println("-------------------");
    //增强for
    for (String s : list) {
    System.out.println(s);
    }

    list集合(可以存储重复元素)

    ArrayList集合 :查询快,增删慢

    LinkedList集合:查询慢,增删快

    //创建对象
    LinkedList<String> linked = new LinkedList<>();
    //使用add方法往集合中添加元素,add等效于addlast
    linked.add("a");
    linked.add("b");
    linked.add("c");
    System.out.println(linked);
    //将指定元素插入列表的头,addfirst等效于push
    linked.addFirst("e");
    //linked.push("e");
    System.out.println(linked);
    //获取集合第一个元素
    String first = linked.getFirst();
    System.out.println(first);
    //获取几何中最后ige元素
    String last = linked.getLast();
    System.out.println(last);
    //移除并返回列表的第一个元素
    linked.removeFirst();
    //移除并返回列表的最后一个元素
    linked.removeLast();
    //移除并返回第一个元素
    linked.pop();
    //判断集合是否为空
    linked.isEmpty();
    //清空集合元素
    linked.clear();

    set集合(1.不允许重复元素2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历)

    HashSet集合

    1.不允许重复元素

    2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历

    3.是一个无序的集合,存储和取出元素的顺序有可能不一致

    4.底层是一个哈希结构(查询速度非常的快)

    //创建对象
    HashSet<Integer> set = new HashSet<>();
    //添加元素
    set.add(2);
    set.add(4);
    set.add(3);
    set.add(4);
    //使用迭代器遍历
    System.out.println(set);
    Iterator<Integer> it = set.iterator();
    while (it.hasNext()){
    Integer next = it.next();
    System.out.println(next);
    }

    //增强for遍历
    for (Integer integer : set) {
    System.out.println(integer);
    }

    collections集合工具类的方法

    //创建对象
    ArrayList<String> list = new ArrayList<>();
    //往集合中添加一些元素
    Collections.addAll(list,"a","b","c","d","e");
    System.out.println(list);
    //打乱集合顺序
    Collections.shuffle(list);
    System.out.println(list);
    Collections.sort(list);
    System.out.println(list);

    排序规则

            //创建对象
    ArrayList<Integer> list = new ArrayList<>();
    //往集合中添加一些元素
    list.add(1);
    list.add(2);
    list.add(3);
    System.out.println(list);
    Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
              //return o1-o2;//升序
    return o2-o1;//降序
    }
    });
    System.out.println(list);

    map集合

    1.是一个双列集合,一个元素包含两个值(一个key,一个value)

    2.集合中的元素,key和value的数据类型可以相同,也可以不同

    3.key不允许重复,value可以重复

    4.key和value是一个对应一个的

    HashMap<String, String> map = new HashMap<>();
    //没有重复返回null
    String v1 = map.put("李晨", "范冰冰");
    System.out.println(v1);

    //返回被替换的值
    String v2 = map.put("李晨", "范冰冰2");
    System.out.println(v2);

    map.put("冷锋","龙小云");
    map.put("杨过","小龙女");
    map.put("尹志平","小龙女");
    System.out.println(map);
    //key存在返回被删除的值,key不存在返回空
    map.remove("冷锋");
    System.out.println(map);
    //根据key获取value
    String v3 = map.get("杨过");
    System.out.println(v3);
    //判断是否含有指定的键,有返回true,没有返回false
    boolean v4 = map.containsKey("杨过");
    System.out.println(v4);

    map集合遍历键找值的方式

    //创建对象
    Map<String, String> map = new HashMap<>();
    map.put("冷锋","龙小云");
    map.put("杨过","小龙女");
    map.put("尹志平","小龙女");

    //使用map集合中的方法keyset,把map集合所有的key取出来,存到set集合中
    Set<String> set = map.keySet();
    //遍历set集合
    Iterator<String> it = set.iterator();
    while (it.hasNext()){
    String next = it.next();
    System.out.println(map.get(next));
    }

    //使用增强for
    for (String key : set) {
    System.out.println(map.get(key));
    }

    entry键值对对象

    //创建对象
    Map<String, String> map = new HashMap<>();
    map.put("冷锋","龙小云");
    map.put("杨过","小龙女");
    map.put("尹志平","小龙女");

    Set<Map.Entry<String, String>> set = map.entrySet();

    //迭代器遍历
    Iterator<Map.Entry<String, String>> it = set.iterator();
    while (it.hasNext()){
    Map.Entry<String, String> next = it.next();
    String key = next.getKey();
    String value = next.getValue();
    System.out.println(key + value);
    }

    //增强for遍历
    for (Map.Entry<String, String> entry : set) {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + value);
    }
  • 相关阅读:
    eclipse连接远程hadoop集群开发时0700问题解决方案
    螺旋线
    双曲抛物面
    双曲抛物面
    工业相机标定相关知识整理
    高科技 stuff
    高科技 stuff
    杜甫诗百首
    杜甫诗百首
    经典纪录片
  • 原文地址:https://www.cnblogs.com/yzcstart/p/11193522.html
Copyright © 2011-2022 走看看