网站建设 >

查看其它板块

6、集合介绍-创新互联

文章目录

6、集合
- 6.1 介绍
- 6.2 常用接口和类
- 6.3 ArrayList
- - 6.3.1 介绍
  - 6.3.2 基本操作
  - 6.3.3 常用方法
- 6.4 LinkedList
- - 6.4.1 基本操作
  - 6.4.2 常用方法
- 6.5 泛型
- - 6.5.1 介绍
  - 6.5.2 基本使用
- 6.6 比较器
- 6.7 ArrayList和LinkedList的比较
- 6.8 HashSet
- - 6.8.1 介绍
  - 6.8.2 常用方法
  - 6.8.3 重复数据
- 6.9 Queue
- 6.10 HashMap
- - 6.10.1 介绍
  - 6.10.2 常用方法
- 6.11 Hashtable
- 6.12 迭代器
- 6.13 工具类
- 6.14问题汇总

创新互联主要从事网站设计制作、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务江达,10多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575

Java零基础极速入门-讲师：海波

失败，是正因你在距成功一步之遥的时候停住了脚步。

6、集合 6.1 介绍

public class Demo {public static void main(String[] args) {//集合
        // 生活中集合，是一个动词

        // Java中集合是一个名词，数据的一种容器，用于容纳数据
        // Java提供了完整的集合框架

        // 问题1：什么时候需要一个容纳数据的容器，也就是集合对象。
            // 当容纳数据个数不确定，Java集合框架就包含了对不确定个数的数据处理的集合类

        // 问题2：如果只是为了容纳数据，可以是直接使用数组，为什么要学习集合。
            // 数组使用起来不方便，在数据不确定的场合，数组使用起来很不方便

        // 总结：不确定有关系的数据，进行相同的逻辑处理的场合，使用集合是一个不错的选择

        // 根据数据的不同，Java的集合分为两大体系
        // 1.单一数据体系 ：Collection接口定义了相关规则
        // 2.成对出现的数据体系：Map接口定义了相关规则
        // 承兑的数据：两个数据有关系，可以根据第一个数据关联第二个数据（键值对数据）

    }

6.2 常用接口和类

public class Demo {public static void main(String[] args) {//集合
        // 1.Collection接口
            // 常用子接口
            // List：按照插入顺序保存数据
                // 具体实现类：ArrayList、LinkedList
            //  Set：集，无需保存，数据不能重复
                // 具体实现类：HashSet
            // Queue：队列（有头有尾）
                // 具体实现类：ArrayBlockingQueue
        // 2.Map接口
            // 常用子接口
            // HashMap： 
            //Hashtable：
    }
}

6.3 ArrayList

在这里插入图片描述

6.3.1 介绍

//集合
// 1.Collection接口-List
// ArrayList：Array + List（使用数组实现存储的容器对象）
// List：列表、清单（按照插入顺序存储）
// Array：数组、阵列

6.3.2 基本操作

public class Demo {public static void main(String[] args) {// 创建集合对象：ArrayList
        ArrayList list = new ArrayList();
        // 1.不需要传递构造参数，直接new就可以（默认底层数组为空数组）
        // 2.构造参数需要传递一个int类型的值，用于设定底层数组的长度
        // 3.构造参数需要传递一个Collection集合类型的值，用于将其他集合中的数据放置在当前集合中

        // 增加数据：添加数据时，如果集合中没有数据，默认创建长度为10的数组
        list.add("张三");
        // 增加数据：增加第二条数据不会再增加数组长度
        list.add("李四");
        // 扩容：当添加数据长度超过10，会创建一个新数组，比旧数组容量大，将旧数组数据复制到新数组，旧数组不再使用

        // 访问数据
        // 获取集合中数据数量
        System.out.println(list.size());
        // 获取指定位置数据
        System.out.println(list.get(0));
        // 遍历集合中的数据
        for (int i = 0; i< list.size(); i++) {System.out.println(list.get(i));
        }
        // foreach（快捷键：list.iter）
        for (Object o : list) {System.out.println(o);
        }

        // 修改数据：将指定位置的数据修改
        // 参数1：修改的位置
        // 参数2：修改的值
        // 方法会返回结果，结果就是更新前的值
        Object old = list.set(1, "王五");
        System.out.println(old);

        // 删除数据：将指定位置的数据删除
        // 参数1：删除的位置
        // 方法会返回结果，结果就是删除的值
        Object remove = list.remove(1);
        System.out.println(remove);

        // 打印集合对象
        System.out.println(list);
    }
}

6.3.3 常用方法

public class Demo {public static void main(String[] args) {// ArrayList的常用方法
        // 创建集合对象：ArrayList
        ArrayList list = new ArrayList();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        // add()：新增加的数据插入到数组指定位置，后面的数据全部后移一位，如果数组空间不足，需要创建新数组
        // 参数1：增加位置的索引
        // 参数2：数据
        list.add(1,"赵六");

        // addAll()：追加其他集合中的数据
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list.addAll(list1);

        // size()：集合中数据的数量
        System.out.println(list.size());
        // clear()：清空集合中数据
        list.clear();
        // removeAll()：删除指定集合中数据
        // 参数1：集合对象
        list.removeAll(list1);
        // contains()：判断集合中是否包含某条数据，返回布尔类型值
        list.contains("张三");
        // indexOf()：获取数据在索引中第一次出现位置（获取不存在数据返回-1，当两个相同数据，返回数据第一个位置索引）
        // 参数1：需要查询字符串
        list.indexOf("张三");
        // lastIndexOf()：获取数据在索引中位置最后出现的位置
        list.lastIndexOf("张三");
        // isEmpty()：集合中数据是否为空
        System.out.println(list.isEmpty());
        // 将集合转换成数组
        list.toArray();
        // 克隆集合对象
        ArrayList list2 = (ArrayList)list.clone();
        // 打印结果
        System.out.println(list);
    }
}

6.4 LinkedList

在这里插入图片描述

6.4.1 基本操作

public class Demo {public static void main(String[] args) {// LinkedList：Linked（连接）+ List（集合）
        //  构建集合对象
        LinkedList list = new LinkedList();

        // 增加一个数据
        list.add("zhangsan");
        // 增加数据到首位
        list.addFirst("list");
        // 增加数据到指定位置
        list.add(1,"wangwu");

        // 获取首位数据
        System.out.println(list.getFirst());
        // 获取末位数据
        System.out.println(list.getLast());
        // 获取全部数据
        System.out.println(list);

        // 根据索引获取数据
        System.out.println(list.get(1));
        // 遍历数据
        for (Object o : list) {System.out.println(o);
        }

        // 修改数据
        list.set(1,"zhaoliu");
        // 获取全部数据
        System.out.println(list);
        // 删除
        System.out.println(list.remove("zhangsan"));
        // 获取全部数据
        System.out.println(list);
    }
}

6.4.2 常用方法

public class Demo {public static void main(String[] args) {// LinkedList：Linked（连接）+ List（集合）
        //  构建集合对象
        LinkedList list = new LinkedList();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");

        // 常用方法
        //list.add(1,"lisi"); 指定位置增加
        //list.addFirst("lisi"); 开头增加
        //list.addLast("lisi"); 结尾增加
        //list.addAll(); 拷贝其他集合中的数据
        //list.remove("lisi"); 删除指定数据
        //list.remove(); 删除第一个
        // list.removeFirst(); 删除第一个
        // list.removeLast(); 删除最后一个
        // list.remove(1); 删除指定下标

        // list.size(); 集合长度
        // list.isEmpty(); 是否为空
        // list.clear(); 清空数据
        // list.contains("list"); 是否包含
        // list.element(); //获取第一个数据
        // list.indexOf("lisi"); 获取数据所在位置
        // list.lastIndexOf("lisi"); 返回元素最后一次出现的位置
        // list.push("aa");//  添加数据到首位
        // list.pop();// 弹出数据,弹出后数据在集合中就消失了
        System.out.println(list);
    }
}

6.5 泛型 6.5.1 介绍

public class Demo {public static void main(String[] args) {// 集合 Collection
        // 泛型语法：在集合处理时，简化数据类型的判断，以及进行类型的转换
        ArrayListlist = new ArrayList<>();
        // 指定集合中只可以储存User对象，不可以存别的对象
        list.add(new User());
        // 从集合中获取只能是User
        User user = list.get(0);
    }
}

class User{}

6.5.2 基本使用

在这里插入图片描述

public class Demo {public static void main(String[] args) {// 泛型语法
        // 有时，泛型也称之为参数类型
        MyContainermyContainer = new MyContainer<>();
        test(myContainer);
        // 1.类型存在多态的使用
        // 2.泛型没有多态
    }

    public static void test(MyContainermyContainer) {System.out.println(myContainer);
    }
}

// 容器类
class MyContainer{public C data;
}

class User {}

6.6 比较器

public class Demo {public static void main(String[] args) {// 比较器
        // Sort 排序
        ArrayListlist = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);

        // 排序需要传递一个实现了比较器接口的对象
        list.sort(new NumberComparater());
        System.out.println(list);
    }
}

//实现了比较器接口的对象
class NumberComparater implements Comparator{@Override
    public int compare(Integer o1, Integer o2) {// o1 >o2 返回正数，升序
        //return o1 - o2;

        // o1< o2 返回负数，降序
        return o2 - o1;

        // o1 = o2 返回0，顺序不发生改变
        //return 0;
    }
}

6.7 ArrayList和LinkedList的比较

在这里插入图片描述

public class Demo {public static void main(String[] args) {// 集合数据容量没有达到数组阈值场景，追加数据ArrayList快
        // 向集合的指定位置插入数据，或集合数据容量不够的场景，LinkedList快
        // 根据索引查询数据，ArrayList快
        // 线性查询数据，两个集合没有本质区别
        
        // 线性查询：一个一个查询

    }
}

6.8 HashSet 6.8.1 介绍

在这里插入图片描述
数据A存储到HashSet，首先通过HASH算法，得到存储位置，将数据放入，取数据通过数组下表顺序取出。

HashSet的数据是无序排列。

可以向HashSet中放入重复数据，但是重复数据存储位置相同，导致存储数据不会重复。

public class Demo {public static void main(String[] args) {// HashSet： Hash + Set
        // Hash：哈希算法，散列算法
        // 基本操作
        HashSetset = new HashSet<>();
        // 增加数据
        set.add("zhangsan");
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        // 打印
        System.out.println(set);
        // HashSet没有修改方法，想修改只能先删除，在添加
        // 删除
        set.remove("wangwu");
        System.out.println(set);
        // 查询数据
        for (String s : set) {System.out.println(s);
        }
    }
}

6.8.2 常用方法

public class Demo {public static void main(String[] args) {// 常用方法
        HashSetset = new HashSet<>();
        // ArrayList数据
        ArrayListlist = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        // 导入其他集合数据
        set.addAll(list);
        // 将HashSet变成数组
        Object[] toArray = set.toArray();
        // 是否为空
        set.isEmpty();
        // 集合清空
        set.clear();
        // 是否包含某个数据
        set.contains("zhangsan");
        // 获取集合长度
        set.size();
        // 复制一个新的集合随想
        set.clone();
    }
}

6.8.3 重复数据

在这里插入图片描述
HashSet判断对象数据重复，先获取对象HashCode值，通过HASH算法，算出存放位置，如果两个对象存放位置相同，但内容不同，两个对象存放在同一个位置，使用链表链接。

public class Demo {public static void main(String[] args) {// 重复判断
        HashSetset = new HashSet<>();

        User user1 = new User();
        user1.id = 1;
        user1.name = "zhangsan";

        User user2 = new User();
        user2.id = 1;
        user2.name = "lisi";

        User user3 = new User();
        user3.id = 3;
        user3.name = "wangwu";

        set.add(user1);
        set.add(user2);
        set.add(user3);

        System.out.println(set);
    }
}

class User {public int id;
    public String name;

    // 从写hashCode，按照用户自定义的标志位做对象区分
    @Override
    public int hashCode() {return id;
    }

    // 重写equeals，按照用户自定义规则比较对象内容
    @Override
    public boolean equals(Object obj) {if (obj instanceof User) {User user = (User) obj;
            if (user.id == this.id) {if (user.name == this.name) {return true;
                }
            }
            return false;
        } else {return false;
        }
    }

    // 重写toString方便打印对象内容
    @Override
    public String toString() {return "User[" + id + "," + name + "]";
    }
}

6.9 Queue

public class Demo {public static void main(String[] args) throws InterruptedException {// Queue：排队
        // ArrayBlockingQueue Array：数组 Blocking：阻塞，堵住 Queue
        ArrayBlockingQueue queue = new ArrayBlockingQueue(3);

        // 添加-add()：当数据增加超过数组设定容量，会直接报错Queue full
        //queue.add("zhangsan");
        //queue.add("lisi");
        //queue.add("wangwu");
        //queue.add("zhaoliu");

        // 添加-put()：当数据增加超过数组设定容量，程序会阻塞
        //queue.put("zhangsan");
        //queue.put("lisi");
        //queue.put("wangwu");
        //queue.put("zhaoliu");

        // 添加-put()：数据添加成功，返回true，当数据增加超过数组设定容量，添加失败，返回false
        boolean zhangsan = queue.offer("zhangsan");
        System.out.println(zhangsan);
        boolean lisi = queue.offer("lisi");
        System.out.println(lisi);
        boolean wangwu = queue.offer("wangwu");
        System.out.println(wangwu);
        boolean zhaoliu = queue.offer("zhaoliu");
        System.out.println(zhaoliu);

        // 取数据，当集合中没有数据，返回null
        //System.out.println(queue.poll());
        //System.out.println(queue.poll());
        //System.out.println(queue.poll());
        //System.out.println(queue.poll());

        // 取数据，当集合中没有数据，阻塞等待添加数据
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
    }
}

6.10 HashMap 6.10.1 介绍

在这里插入图片描述
HashMap存储数据，首先通过HASH算法，计算key（A）的存放位置，将（key，value）储存，有可能不相同的key存放相同位置，同位置使用单向链表链接，Java为了增强HashMap的查询速度，单向链表使用红黑树优化。

public class Demo {public static void main(String[] args) throws InterruptedException {// HashMap:Hash + Map
        // 数据存储无序，且key不能重复
        // 数据格式（key，value）
        HashMapmap = new HashMap<>();

        // 添加数据：put
        map.put(1,"zhangsan");
        // 修改数据，put方法也可以，返回值就是被修改的数据
        System.out.println(map.put(1, "zhaoliu"));
        map.put(2,"lisi");
        map.put(3,"wangwu");

        // 查询数据
        System.out.println(map.get(1));

        // 删除数据
        map.remove(1);

        // 打印所有数据
        System.out.println(map);
    }
}

6.10.2 常用方法

public class Demo {public static void main(String[] args) throws InterruptedException {// HashMap:Hash + Map
        // 数据存储无序
        HashMapmap = new HashMap<>();

        // 添加数据：put
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");

        // key不存在就添加，key存在，不添加
        map.putIfAbsent(1,"Tom");

        //修改数据，返回修改前的数据
        System.out.println(map.replace(1, "Tom"));

        // 清空clear
        // map.clear();

        // 获取map集合中所有的key
        Setset = map.keySet();
        // 通过获取全部key遍历value，有true无false
        for (Integer integer : set) {System.out.println(map.get(integer));
        }

        // 判断当前map集合中有没有指定的key
        System.out.println(map.containsKey(1));

        // 获取全部value
        Collectionvalues = map.values();
        for (String value : values) {System.out.println(value);
        }

        // 判断当前map集合中有没有指定的value
        System.out.println(map.containsValue("Tom"));
        // 打印map
        System.out.println(map);

        // 获取键值对对象
        Set>entries = map.entrySet();
        for (Map.Entryentry : entries) {System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        // 删除一个键值对
        map.remove(1);
        System.out.println(map);

        // 删除一个特定的键值对（只有键值对都相等才能删除）
        map.remove(2,"lisi");
        System.out.println(map);
    }
}

6.11 Hashtable

public class Demo {public static void main(String[] args) throws InterruptedException {// Hashtable:Hash + table
        Hashtable table = new Hashtable();
        table.put(null,null);
        HashMap map = new HashMap();
        map.put(null,null);
        // HashMap与Hashtable区别
        // 1.实现方式不一样：继承父类不一样
        // 2.底层结构容量不同：HashMap(16),Hashtable(11)
        // 3.HashMap的K，V都可以为null，HashMap的K，V都不可以为null
        // 4.HashMap的数据定位采用的是Hash算法，但是Hashtable采用的是hashcode
        // 5.HashMap的性能较高（不支持多线程），Hashtable（支持多线程）的性能较低

    }
}

6.12 迭代器

public class Demo {public static void main(String[] args) throws InterruptedException {// 当使用循环遍历时，对HashMap进行修改会报错。
        // HashMap 创建 复制
        HashMapmap = new HashMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");

        //  获取所有key
        Setset = map.keySet();

        // 迭代器
        Iteratoriterator = set.iterator();
        // hasNext()：用来判断是否存在下一跳数据
        while(iterator.hasNext()){// 获取下一条数据
            Integer next = iterator.next();

            // 在取值的过程中删除数据，使用迭代器删除，这样就不报错了
            if(2 == next){//remove()方法只能删除当前数据，不能删除其他数据
                iterator.remove();
            }

            System.out.println(map.get(next));
        }
    }
}

在这里插入图片描述

6.13 工具类

public class Demo {public static void main(String[] args) throws InterruptedException {// Arrays 集合工具类
        int[] is = {2, 3, 1, 5, 4};
        int[] is1 = {1, 2, 3, 4, 5};
        // 将数组变成字符串
        System.out.println(Arrays.toString(is));
        // 将数组变成字符串
        System.out.println(is);
        // 获取list集合并赋值
        Listlist = Arrays.asList(1, 2, 3, 4, 5, 6);
        // 排序（默认升序）
        Arrays.sort(is);
        System.out.println(Arrays.toString(is));
        // 二分查找法（查询排序后的顺序的位置）
        System.out.println(Arrays.binarySearch(is, 5));
        // 数组的比较，比较数组内容是否相等（包括数组内顺序）
        System.out.println(Arrays.equals(is, is1));
        // 数组的比较，指定范围，比较数组内容是否相等（包括数组内顺序）
        System.out.println(Arrays.equals(0,5, is,0,5is1));

    }
}

6.14问题汇总

public class Demo {public static void main(String[] args) throws Exception {// 集合Exception
        // 容量：当前的容量不能小于0
        ArrayList list = new ArrayList(10);
        list.add("a");
        list.add("b");
        list.add("c");

        // 如果访问的集合是数组，那么索引范围就是0，到数组长度-1
        // 如果访问的集合是List，那么索引范围就是0，到数据长度-1
        System.out.println(list.get(2));

        // NoSuchElementException
        LinkedList linkedList = new LinkedList();
        //System.out.println(linkedList.getFirst());

        // 在遍历的过程中集合数据数量发生改变，就会发生错误，所以在循环的时候处理集合，一定要使用迭代器
        HashMap map = new HashMap();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");

        for (Object o : map.keySet()) {if( "b".equals(o)){map.remove(o);
            }
            System.out.println(map.get(o));
        }
    }
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

网页标题：6、集合介绍-创新互联
网页路径：http://cdkjz.cn/article/jhccc.html

返回首页了解更多建站资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线成都：13518219792 座机：028-86922220

在线咨询提交需求

友情链接交换友情链接

广汉锦华橡塑木包装箱成都名片印刷九针服饰卡多尼人工智成都网站制作成都网站设计凯亚自动化控制成都SEO优化公司邛崃网站建设

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层建设咨询028-86922220

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图

网站建设

网站推广

案例

方案

电商网站开发

微信小程序

我们

联系

精准传达 • 有效沟通

查看其它板块

6、集合介绍-创新互联

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

大客户专线成都：13518219792 座机：028-86922220

友情链接交换友情链接

网络推广

Network promotion

网站方案

Solution

电商网站开发

E-commerce & System

我们

About Us

联系

Contact Us

精准传达 • 有效沟通

查看其它板块

6、集合介绍-创新互联

相关资讯

python生成网页验证码的方法-创新互联

python模拟ssh登录-创新互联

如何用go语言设计一个栈？-创新互联

好程序员大数据学习路线之大数据自学路线二-创新互联

Android手势ImageView三部曲第三部-创新互联

c#中如何使用BackgroundWorker-创新互联

php下载中文文件乱码怎么办-创新互联

python读取图片的几种方式及图像宽和高的存储顺序-创新互联

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

大客户专线 成都：13518219792 座机：028-86922220

友情链接 交换友情链接

大客户专线成都：13518219792 座机：028-86922220

友情链接交换友情链接