18_集合_第1天（Collection、迭代器、泛型）

最新推荐文章于 2024-03-14 16:02:11 发布
最新推荐文章于 2024-03-14 16:02:11 发布
阅读量790 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w1103693423/article/details/78982916
版权

第18天 集合

  1. 集合

    1. 集合介绍

集合，集合是java中提供的一种容器，可以用来存储多个数据。

在前面的学习中，我们知道数据多了，可以使用数组存放或者使用ArrayList集合进行存放数据。那么，集合和数组既然都是容器，它们有啥区别呢？

  • 数组的长度是固定的。集合的长度是可变的。
  • 集合中存储的元素必须是引用类型数据

  1. ArrayList集合存储元素

我们来回顾下，使用ArrayList集合存储元素并遍历的过程。

  • 练习一：ArrayList集合存储5个int类型元素

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<Integer>();

    list.add(111);

    list.add(222);

    list.add(333);

    list.add(444);

    list.add(555);

    for(int i=0; i<list.size(); i++){

System.out.println(list.get(i));

}

}

  • 练习二：ArrayList集合存储5个Person类型元素

public static void main(String[] args) {

ArrayList<Person> list = new ArrayList<Person>();

    list.add(new Person("小强"));

    list.add(new Person("老王"));

    list.add(new Person("小虎"));

    list.add(new Person("小泽"));

    list.add(new Person("小红"));

    for(int i=0; i<list.size(); i++){

        Person p = list.get(i);

System.out.println(p);

}

}

  1. 集合的继承实现关系

查看ArrayList类发现它继承了抽象类AbstractList同时实现接口List，而List接口又继承了Collection接口。Collection接口为最顶层集合接口了。 采集，聚集

源代码：

interface List extends Collection {

}

public class ArrayList extends AbstractList implements List{

}

这说明我们在使用ArrayList类时，该类已经把所有抽象方法进行了重写。那么，实现Collection接口的所有子类都会进行方法重写。

  • Collecton接口常用的子接口有：List接口、Set接口
  • List接口常用的子类有：ArrayList类、LinkedList类
  • Set接口常用的子类有：HashSet类、LinkedHashSet类

  1. Collection接口概述

既然Collection接口是集合中的顶层接口，那么它中定义的所有功能子类都可以使用。查阅API中描述的Collection接口。Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

继续查阅API，发现Collection接口中很多集合的操作方法，那么这些方法都具体能做什么呢？

  1. Collection接口的基本方法

这里我们不关心具体创建的Collection中的那个子类对象，这里重点演示的是Collection接口中的方法。

创建集合的格式：

方式1：Collection<元素类型> 变量名 = new ArrayList<元素类型>();

方式2：Collection 变量名 = new ArrayList();

  • 方式1创建的集合，只能存储<>中指定的元素类型，该方式为常用方式
  • 方式2创建的集合，集合的元素类型默认为Object类型，即任何类型的元素都可以存储。

 

演示Collection接口中的方法

//创建集合

Collection coll = new ArrayList();

 

//1,往集合中添加对象元素。add(E e)方法，E代表创建集合时所指定的数据类型如<String>，那么，E就代表String类型；创建集合时若没有指定数据类型，那么，E就代表Object类型。

coll.add("itcast1");

coll.add("itcast2");

coll.add("itcast3");        

//把集合打印一下。

System.out.println(coll); //打印结果为：[itcast1, itcast2, itcast3]

System.out.println(coll.toString()); //打印结果为：[itcast1, itcast2, itcast3]

 

//2,从集合中删除元素。remove(Object o)方法

coll.remove("itcast2");        

//删除后，集合元素为[itcast1, itcast3]

 

//3,判断集合中是否包含指定元素。contains(Object o)方法

System.out.println(coll.contains("itcast1"));

//打印结果为true

System.out.println(coll.contains("itcast2"));

//打印结果为false

    

//4,获取集合元素个数。size()方法

System.out.println(coll.size());

//打印结果为2

 

//5,返回包含集合中所有元素的数组。toArray()方法

String[] array = coll.toArray();

//数组中的元素为{"itcast1", "itcast3"}

 

//6,清除集合元素。remove()方法

coll.clear();

//清空后，集合元素为[]，代表没有元素

  1. Iterator迭代器

    1. Iterator迭代器概述

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。

Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下：

  • hasNext（）方法：用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。
  • next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

     

    迭代集合元素图解：

  1. Iterator迭代方式的代码体现

在Collection接口描述了一个抽象方法iterator方法，所有Collection子类都实现了这个方法，并且有自己的迭代形式。

进行代码演示：

//1，创建集合对象。

Collection<String> coll = new ArrayList<String>();

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

 

//2.获取容器的迭代器对象。通过iterator方法。

Iterator it = coll.iterator();

 

//3,使用具体的迭代器对象获取集合中的元素。参阅迭代器的方法

while(it.hasNext()){

    System.out.println(it.next());

}

 

/*

迭代器for循环的形式的使用

for (Iterator it = coll.iterator(); it.hasNext(); ) {

    System.out.println(it.next());

}

*/

注意：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

  1. 集合元素的向下转型

学习到这里，基本知道了Collection接口的简单使用。可是集合中可以存储任何对象，那么存放进去的数据都是还是原来类型吗？不是了，提升成了Object。

在使用集合时，我们需要注意以下几点：

  • 集合中存储其实都是对象的地址。
  • 集合中可以存储基本数值吗？jdk1.5版本以后可以存储了。因为出现了基本类型包装类，它提供了自动装箱操作（基本类型à对象），这样，集合中的元素就是基本数值的包装类对象。
  • 存储时提升了Object。取出时要使用元素的特有内容，必须向下转型。

Collection coll = new ArrayList();

coll.add("abc");

coll.add("aabbcc");

coll.add("shitcast");

Iterator it = coll.iterator();

while (it.hasNext()) {

    //由于元素被存放进集合后全部被提升为Object类型

//当需要使用子类对象特有方法时，需要向下转型

    String str = (String) it.next();

    System.out.println(str.length());

}

注意：如果集合中存放的是多个对象，这时进行向下转型会发生类型转换异常。

 

提示：Iterator接口也可以使用<>来控制迭代元素的类型的。代码演示如下：

Collection<String> coll = new ArrayList<String>();

coll.add("abc");

coll.add("aabbcc");

coll.add("shitcast");

Iterator<String> it = coll.iterator();

while (it.hasNext()) {

    String str = it.next();

//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型

    System.out.println(str.length());

}

 

 

  1. 增强for循环

增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型 变量 : Collection集合or数组){

}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

练习一：遍历数组

int[] arr = new int[]{11,22,33};

for (int n : arr) {//变量n代表被遍历到的数组元素

    System.out.println(n);

}

 

练习二:遍历集合

Collection<String> coll = new ArrayList<String>();

coll.add("itcast1");

coll.add("itcast2");

coll.add("itcast3");

coll.add("itcast4");

for(String str : coll){//变量Str代表被遍历到的集合元素

    System.out.println(str);

}

增强for循环和老式的for循环有什么区别？

注意：新for循环必须有被遍历的目标。目标只能是Collection或者是数组。

建议：遍历数组时，如果仅为遍历，可以使用增强for如果要对数组的元素进行 操作，使用老式for循环可以通过角标操作。

  1. 泛型

    1. 泛型的引入

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。比如下面程序：

public class GenericDemo {

    public static void main(String[] args) {

        List list = new ArrayList();

        list.add("abc");

        list.add("itcast");

        list.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放

        Iterator it = list.iterator();

        while(it.hasNext()){

            //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型

            String str = (String) it.next();

            System.out.println(str.length());

        }

    }

}

 

程序在运行时发生了问题java.lang.ClassCastException

为什么会发生类型转换异常呢？我们来分析下：

由于集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时 ClassCastException。怎么来解决这个问题呢？使用集合时，必须明确集合中元素的类型。这种方式称为：泛型。

  1. 泛型的定义与使用

我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

  1. 含有泛型的类

    定义格式：修饰符 class 类名<代表泛型的变量> { }

  • 例如，API中的ArrayList集合：

class ArrayList<E>{

public boolean add(E e){ }

    public E get(int index){ }

}

 

    使用格式：创建对象时，确定泛型的类型

  • 例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型

class ArrayList<String>{

public boolean add(String e){ }

    public String get(int index){ }

}

  • 例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型

class ArrayList<Integer>{

public boolean add(Integer e){ }

    public Integer get(int index){ }

}

 

  1. 含有泛型的方法

定义格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

  • 例如，API中的ArrayList集合中的方法：

public <T> T[] toArray(T[] a){ }

//该方法，用来把集合元素存储到指定数据类型的数组中，返回已存储集合元素的数组

 

使用格式：调用方法时，确定泛型的类型

  • 例如

    ArrayList<String> list = new ArrayList<String>();

    String[] arr = new String[100];

    String[] result = list.toArray(arr);

此时，变量T的值就是String类型。变量T，可以与定义集合的泛型不同

public <String> String[] toArray(String[] a){ }

  • 例如

    ArrayList<String> list = new ArrayList<String>();

    Integer[] arr = new Integer[100];

    Integer [] result = list.toArray(arr);

此时，变量T的值就是Integer类型。变量T，可以与定义集合的泛型不同

public <Integer> Integer[] toArray(Integer[] a){ }

 

  1. 含有泛型的接口

    定义格式：修饰符 interface接口名<代表泛型的变量> { }

  • 例如，API中的Iterator迭代器接口

public interface Iterator<E> {

    public abstract E next();

}

    

使用格式：

1、定义类时确定泛型的类型

  • 例如

public final class Scanner implements Iterator<String> {

public String next(){ }

}

此时，变量E的值就是String类型。

 

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

  • 例如

    ArrayList<String> list = new ArrayList<String>();

    Iterator<String> it = list.iterator();

此时，变量E的值就是String类型。

public interface Iterator<String> {

    public abstract String next();

}

 

 

  1. 使用泛型的好处

  • 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
  • 避免了类型强转的麻烦。

演示下列代码：

public class GenericDemo {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        list.add("abc");

        list.add("itcast");

        //list.add(5);//当集合明确类型后，存放类型不一致就会编译报错

        //集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型

        Iterator<String> it = list.iterator();

        while(it.hasNext()){

    String str = it.next();

//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型

            System.out.println(str.length());

        }

    }

}

  1. 泛型通配符

泛型是在限定数据类型，当在集合或者其他地方使用到泛型后，那么这时一旦明确泛型的数据类型，那么在使用的时候只能给其传递和数据类型匹配的类型，否则就会报错。

代码演示：

  • 定义迭代集合元素的方法

public static void printCollection(Collection<Person> list) {

    Iterator<Person> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

  • 调用方法

Collection<Student> list = new ArrayList<Student>();

printCollection(list);

上面调用方法语句属于语法错误，因为泛型限定不一致。方法要的是Collection<Person>类型，传入的是Collection<Student>，二者类型不匹配。

 

上述定义的printCollection方法中，由于定义的是打印集合的功能，应该是可以打印任意集合中元素的。但定义方法时，根本无法确定具体集合中的元素类型是什么。为了解决这个"无法确定具体集合中的元素类型"问题，java中，为我们提供了泛型的通配符<?>。

  • 对上面的方法，进行修改后，实现了可迭代任意元素类型集合的方法

public static void printCollection(Collection<?> list) {

    Iterator<?> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

  • 总结一下：

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

  1. 泛型限定

上述打印集合的功能，看似很强大，可以打印任意集合，可是问题也来了。如果想要对被打印的集合中的元素类型进行限制，只在指定的一些类型，进行打印。怎么做呢？

要解决这个问题，我们就要学习泛型的限定。

  • 限定泛型的上限：
    • 格式：? extends E

      ? 代表接收E类型或者E的子类型的元素

    • 例如，泛型限定为：? extends Person

      则 ? 代表接收Person类型或者Person子类型的元素

 

  • 限定泛型的下限：
    • 格式：? super E

      ? 代表接收E类型或者E的父类型的元素

    • 例如，泛型限定为：? super Student

      则 ? 代表接收Student类型或者Student父类型的元素

       

  • 练习：修改下面的方法，使该方法可以打印学生和工人的集合

class Student extends Person{ }

class Worker extends Person{ }

 

public static void printCollection(Collection<?> list) {

    Iterator<?> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

分析一下，我们可以找到学生和工人的共性类型Person。那么，泛型的限定可以这样书写：

? extends Person : 接收Person类型或者Person的子类型。修改方法如下：

public static void printCollection(Collection<? extends Person> list) {

    Iterator<? extends Person> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

  1. 总结

    1. 知识点总结

  • Collection:集合的顶层接口，定义了集合中通用的功能方法

    常用方法：

    • boolean add(Object e) 把给定的对象添加到当前集合中
    • void clear() 清空集合中所有的元素
    • boolean remove(Object o) 把给定的对象在当前集合中删除
    • boolean contains(Object o) 判断当前集合中是否包含给定的对象
    • boolean isEmpty() 判断当前集合是否为空
    • Iterator iterator() 迭代器，用来遍历集合中的元素的
    • int size() 返回集合中元素的个数
    • Object[] toArray() 把集合中的元素，存储到数组中
  • Iterator: 迭代器
    • Object next()返回迭代的下一个元素
    • boolean hasNext()如果仍有元素可以迭代，则返回 true。
  • 增强for

    简化数组和Collection集合的遍历

    格式：

        for(元素数据类型 变量 : 数组或者Collection集合) {

            使用变量即可，该变量就是元素

        }

    好处：简化遍历

  • 泛型： 用来约束数据的数据类型
    • 泛型的格式：

        <数据类型>

        泛型可以使用在 类，接口，方法上

  • 泛型的好处

        A:将运行期遇到的问题转移到了编译期

        B:省去了类型强转的麻烦

  • 泛型高级(通配符):
    • 泛型通配符<?>

    泛型类型不确定时，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

    • <? extends E>

                向上限定，E及其子类

                ? extends Animal

                ? 代表的就是Animal类本身或者是Animal类的子类

  • <? super E>

                向下限定，E及其父类

                ? super Animal

                ? 代表的就是Animal类本身或者是Animal类的父类

易天殇
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
第7天（集合【迭代器、增强for、泛型】）v201703101
08-08
在实际开发中，理解并熟练掌握集合、迭代器和泛型的概念及用法，将极大地提升代码质量，提高程序的可维护性和效率。学习这些内容不仅有助于编写出更加高效和安全的代码，也是成为专业Java开发人员的基础。
JavaSE——Collection迭代器的使用及源码分析、集合删除元素、Collection常用方法
weixin_51351637的博客
10-20 946
存放在集合中的类型，一定要重写equals方法，下面我们会在contains方法中解释 Collection中能存放什么元素？ 没有使用泛型之前，Collection中可以存储Object所有的子类型 使用了泛型之后，Collection中智能存储某个具体的类型 集合中不能直接存储基本数据类型，也不能存储java对象，只是存储java对象的内存地
最全面的Collection集合和迭代器
黑妖问路的博客
03-30 474
集合Collection以及遍历它的方法---迭代器
Java中Collection集合、Iterator迭代器、泛型
最新发布
m0_60607562的博客
03-14 293
泛型表示：使用 < 元素类型 > 指明集合中存储数据的类型。如：Collection 变量名 = new ArrayList();Java 中的伪泛型：泛型只在编译的时候存在，编译之后就擦除，在编译之前就可以限定其集合的类型小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
Collection,Collection的迭代器(Iterator)
MIRACLE_SQ的博客
08-14 332
Collection的体系结构
Collection集合&Iterator迭代器&泛型
m0_63158445的博客
02-22 462
** Collection、Iterator、泛型、数据结构 能够说出集合与数组的区别 数组: 1.是引用数据类型的一种,可以存储多个元素 2.数组的长度是固定的 int[] arr1 = new int[10]; int[] arr2 = {1,2,3}; 3.数组即可以存储基本类型的数据,又可以存储引用数据类型的数据 int[],double[],String[],Student[] 集合: 1.是引用数据类型的一种,可以存储多个元素 2.集合的长度是可以变化的(可以往集
第16章：Java集合.zip_java 集合_java集合
09-24
Java集合框架是Java编程语言中的一个核心特性，它为存储、管理和操作对象提供了一组统一的接口和类。本章内容主要围绕Java集合框架展开，包括ArrayList、LinkedList、HashSet、HashMap等常见数据结构的使用方法及其...
Java高级特性 第一章 集合框架和泛型
10-23
Java高级特性系列第一章：集合框架和泛型 Collections Framework是Java语言中一个基础的数据结构.framework，它提供了多种类型的数据结构，包括List、Set、Map等，帮助开发者更方便地存储和管理数据。 为什么不...
Java_jihe2.rar_java集合
09-24
- `iterator()`：获取迭代器，遍历集合。 - `toArray()`：转换为数组。 8. **泛型** - 泛型用于限制集合中元素的类型，避免类型转换异常，提高代码安全性。 9. **Stream API** - Java 8引入的新特性，允许对...
第8章 集合类与泛型程序设计
06-23
第一个树以Collection接口为根，它是所有集合类的基础，提供了通用的操作方法，如添加、删除和遍历元素。Collection接口的子接口包括Set和List，分别支持无序不重复元素和有序元素的操作。第二棵树以Map接口为根，...
java之Collection
热门推荐
m0_46191714的博客
01-31 2万+
主要内容 Collection集合 迭代器 增强for List集合 Set集合 学习目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够说出List集合和Set集合的区别 能够说出List集合各种实现类的区别 能够说出Set集合各种实现类的区别 能够说出Collection和Map集合的区别 说出Map集合的常用功能 能够遍历Map集
Collection与迭代器
fqc的博客
08-03 207
Collection java.util.Collection单列集合的顶层接口 没有任何的直接实现类 方法 public boolean add(E e): 把给定的对象添加到当前集合中. public void clear(): 清空集合中的所有元素. public boolean remove(E e): 把给定的元素在当前集合中删除. ...
18_集合框架_第18天_集合、Iterator迭代器、增强for循环 、泛型_讲义
小强博客
11-15 450
今日内容介绍 1、集合 2、Iterator迭代器 3、增强for循环 4、泛型 01集合使用的回顾 *A:集合使用的回顾 *a.ArrayList集合存储5个int类型元素 *b.ArrayList集合存储5个Person类型元素 package cn.incast.demo01; public class Person { private String name; private int...
1、集合 2、Iterator迭代器 3、增强for循环 4、泛型
weixin_33869377的博客
06-02 160
01集合使用的回顾 *A:集合使用的回顾 *a.ArrayList集合存储5个int类型元素 public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(...
Collection集合、迭代器、泛型(超详细)
平安
08-02 2213
 本文主要介绍Collection集合、迭代器、泛型的定义以及详细的使用方法。 目录 Collection集合 1.集合定义 2.集合和数组的区别 3.Collection集合常用功能 Iterator迭代器 1.Iterator接口 2.增强for循环 泛型 1.概念 2.为什么要用泛型 3.定义与使用 总结 Collection集合 1.集合定义       集...
[Day18]集合框架Collection、迭代器、增强for循环以及泛型
weixin_30491641的博客
04-07 122
1.集合 　　1.1集合-本身是一个存储的容器 　　　　集合类的基本接口是Collection接口，这个接口有两个基本方法 　　　　（1）boolean add(E element) 　　　　　　用于向集合中添加元素，如果添加元素确实改变了集合就返回true，否则返回false 　　　　（2）Interator<E> interator(); 　　　　　　返回一个实现了In...
黑马程序员-- 集合框架 （Collection， Iterator，泛型）
u014298549的博客
09-09 426
java提供了一种可以存数一组数据的数据结构，其提供了丰富的方法，在实际开发中往往比数组使用的广泛。这种数据结构成为集合:Collection。 Collection是一个接口，其定义了集合的相关功能方法。
Collection集合,Iterator迭代器，泛型
weixin_43917392的博客
12-04 184
Collection集合,Iterator迭代器，泛型 1.两种容器 A.数组（存放任意类型，长度固定） B.集合（存放对象类型，长度可变） 2.体系结构 单列集合 Collection List (ArrayList、LinkedList、Vector) Set (HashSet、LinkedHashSet、TreeSet) 3、获取迭代器对象和使用方法 Iterator&...
黑马程序员——Java基础---集合（第18天 ）
chao100ge的博客
07-06 488
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一、System静态类 System:类中的方法和属性都是静态的。 static PrintStream out:  标准输出，默认是控制台。 static PrintStream in：  标准输入，默认是键盘。 1、常用方法 1.1、获取系统属性信息System.
Java集合与泛型：Collection、List、迭代器与数据结构详解
在Java编程中，第14天的学习主要聚焦于"Collection、泛型、简单数据结构和List"这一主题。首先，我们从概念层面理解Collection，它是Java中提供的一个容器，用于存储多个数据。与数组相比，集合的关键特性在于其长度...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值