精华内容
下载资源
问答
  • 1. 集合的定义 什么是集合呢? 定义:集合是一个存放对象的引用的容器。 在Java中,集合位于java.util包下。 2. 集合和数组的区别(面试常问) 提到容器,就会想起数组,那么集合和数组的区别是什么呢?(这里是重点,...

    1. 集合的定义

    什么是集合呢?

    定义:集合是一个存放对象的引用的容器。

    在Java中,集合位于java.util包下。

    2. 集合和数组的区别(面试常问)

    提到容器,就会想起数组,那么集合和数组的区别是什么呢?(这里是重点,面试可能问的比较多)

    1. 数组和集合都是Java中的容器
    2. 数组的长度是固定的,集合的长度是可变的
    3. 数组只能存储相同数据类型的数据,这里的数据类型可以是基本数据类型,也可以是引用类型
    4. 集合可以存储不同数据类型的对象的引用(但一般情况下,我们会使用泛型来约定只使用1种数据类型),但不能存储基本数据类型

    空口无凭,我们来点代码配合理解,首先,我们看下如下的数组代码:

    String[] platformArray = new String[3];
    platformArray[0] = "博客园";
    platformArray[1] = "掘金";
    platformArray[2] = "微信公众号";
    platformArray[3] = "个人博客";

    运行代码就会发现,platformArray[3] = "个人博客";会引发java.lang.ArrayIndexOutOfBoundsException异常。

    而使用集合时就不存在这个问题,因为集合在声明时不需要指定长度并且长度会根据放入元素的多少而变化:

    List<String> platformList = new ArrayList<>();
    platformList.add("博客园");
    platformList.add("掘金");
    platformList.add("微信公众号");
    platformList.add("个人博客");

    观察上面声明数组的代码,我们可以推断出下面的代码肯定是编译不通过的:

    String[] platformArray = new String[3];
    platformArray[0] = "博客园";
    platformArray[1] = "掘金";
    platformArray[2] = 1;

    因为数组声明时用的是String类型,而platformArray[2] = 1;赋值时却使用了int类型。

    再来看下下面的集合代码:

    List<int> intList = new ArrayList<int>();
    intList.add(1);
    intList.add(2);
    intList.add(3);

    这段代码也是编译不通过的,在IDEA中,鼠标悬停时会提示如下的错误信息:

    424537-20190726143046241-306002694.png

    意思是类型参数不能是原始类型(基本数据类型),那怎么使用呢?总不能不让我使用int型的集合吧?

    当然不会,Java为每种基本数据类型都提供了对应的包装类,这里修改为int类型对应的包装类Integer即可:

    List<Integer> intList = new ArrayList<Integer>();
    intList.add(1);
    intList.add(2);
    intList.add(3);

    以下为Java的原始类型(基本数据类型)与其对应的包装类:

    原始类型(基本数据类型) 包装类
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean

    3. 集合的分类

    在Java中,集合主要分为以下3种:

    1. List集合
    2. Set集合
    3. Map集合

    它们之间的继承关系可以参考下图。

    424537-20190726152617023-324785479.png

    从上图可以总结出如下几点:

    1. Java集合的根接口是Collection,它又继承了迭代接口Iterable
    2. List接口和Set接口继承了Collection接口
    3. Map接口是独立的接口,并没有继承Collection接口 (这里是重点,面试可能问的比较多)
    4. List接口常用的实现类有:ArrayList、LinkedList、Vector
    5. Set接口常用的实现类有:HashSet、LinkedHashSet、TreeSet
    6. Map接口常用的实现类有:HashMap、HashTable、TreeMap

    4. List集合

    List集合包括List接口以及List接口的所有实现类。List集合具有以下特点:

    1. 集合中的元素允许重复
    2. 集合中的元素是有顺序的,各元素插入的顺序就是各元素的顺序
    3. 集合中的元素可以通过索引来访问或者设置

    List接口常用的实现类有:ArrayList、LinkedList、Vector。

    我们先看下如下示例了解下List集合的用法:

    package collection;
    
    import java.util.*;
    
    public class Muster {
        public static void main(String[] args) {
            List<String> strList = new ArrayList<>();
            strList.add("a");
            strList.add("b");
            strList.add("c");
    
            int i = (int) (Math.random() * strList.size());
            System.out.println("随机获取数组中的元素:" + strList.get(i));
    
            strList.remove(2);
    
            System.out.println("将索引为2的元素从列表移除后,数组中的元素是:");
            for (int j = 0; j < strList.size(); j++) {
                System.out.println(strList.get(j));
            }
        }
    }

    以上代码的输出结果为:

    随机获取数组中的元素:a

    将索引为2的元素从列表移除后,数组中的元素是:

    a

    b

    关于List集合的详细用法,ArrayList、LinkedList、Vector的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    5. Set集合

    Set集合包括Set接口以及Set接口的所有实现类。Set集合具有以下特点:

    1. 集合中不包含重复元素(你可以重复添加,但只会保留第1个)
    2. 集合中的元素不一定保证有序

    Set接口常用的实现类有:HashSet、LinkedHashSet、TreeSet。

    我们先看下如下示例了解下Set集合的用法:

    package collection;
    
    import java.util.*;
    
    public class Muster {
        public static void main(String[] args) {
            Set<String> platformList = new HashSet<>();
            platformList.add("博客园");
            platformList.add("掘金");
            platformList.add("微信公众号");
            platformList.add("个人博客");
    
            // 尝试添加重复元素
            platformList.add("博客园");
            platformList.add("掘金");
    
            for (String platform : platformList) {
                System.out.println(platform);
            }
        }
    }

    以上代码的输出结果为:

    博客园

    个人博客

    掘金

    微信公众号

    可以看出,虽然我们尝试添加了重复元素,但并没有添加成功并且输出的元素没有顺序。

    因此当你的集合中不允许有重复元素并且对排序也没有要求的话,可以使用Set集合。

    关于Set集合的详细用法,HashSet、LinkedHashSet、TreeSet的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    6. Map集合

    Map集合包括Map接口以及Map接口的所有实现类。Map集合具有以下特点:

    1. Map接口并没有继承Collection接口,提供的是key到value的映射
    2. Map中不能包含相同的key

    Map接口常用的实现类有:HashMap、HashTable、TreeMap。

    我们先看下如下示例了解下Map集合的用法:

    package collection;
    
    import java.util.*;
    
    public class Muster {
        public static void main(String[] args) {
            Map<Integer, String> platformMap = new HashMap<>();
            platformMap.put(1, "博客园");
            platformMap.put(2, "掘金");
            platformMap.put(3, "微信公众号");
            platformMap.put(4, "个人博客");
    
            // 尝试添加重复Map
            platformMap.put(4, "个人博客");
    
            // 获取所有的key
            Set<Integer> keys = platformMap.keySet();
            for (Integer integer : keys) {
                System.out.println("Key:" + integer + ",Value:" + platformMap.get(integer));
            }
        }
    }

    以上代码的输出结果为:

    Key:1,Value:博客园

    Key:2,Value:掘金

    Key:3,Value:微信公众号

    Key:4,Value:个人博客

    从日志可以看出,当我们尝试重加重复Map时,并没有添加成功。

    关于Map集合的详细用法,HashMap、HashTable、TreeMap的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    7. 源码及参考

    Java集合中List,Set以及Map等集合体系详解(史上最全)

    8. 最后

    打个小广告,欢迎扫码关注微信公众号:「申城异乡人」,定期分享Java技术干货,让我们一起进步。

    424537-20190716113923826-55678474.png

    转载于:https://www.cnblogs.com/zwwhnly/p/11251562.html

    展开全文
  • 如何定义集合集合与列表有什么区别? 目录如何定义集合集合与列表有什么区别?如何定义集合集合与列表有什么区别? 如何定义集合? 使用大括号 {} 或者 set() 函数来创建 格式如下。 parame = {value01,...

    如何定义集合,集合与列表有什么区别?

    如何定义集合?

    • 使用大括号 {} 或者 set() 函数来创建

    格式如下。

    parame = {value01,value02,...}
    或者
    set(value)
    

    创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

    集合与列表有什么区别?

    直接回答就是。

    • 集合set 元素不可重复
    • 列表 元素可以重复
    • 列表是有序
    • 集合是无序

    由上面的回答我们可以在引出两个问题。

    1. 什么是可重复与不可重复
    2. 什么是有序什么是无序

    可重复与不可重复如下。

    # 列表可重复
    alist = [1, 1, 2, 2, 3, 3]
    print(alist)  # [1, 1, 2, 2, 3, 3]
    
    # 集合不可重复
    bset = {1, 1, 2, 2, 3, 3}
    print(bset)  # {1, 2, 3}
    

    上面例子中我们可以看出集合的元素是不可重复,如果出现重复会自动帮我们去除重复的元素。

    有序与无序如下。

    # 列表有序
    alist = ['今天', '天气', '真好', '啊']
    print("列表:%s" % alist)
    
    # 集合无序
    bset = {'今天', '天气', '真好', '啊'}
    print("集合:%s" % bset)
    
    

    输出结果:

    列表:['今天', '天气', '真好', '啊']
    集合:{'天气', '真好', '今天', '啊'}
    

    上面例子我们可以看出集合的输出是无序的,还有一个简单的判断就是是否可索引
    列表有索引 集合没有 即无序。

    集合中元素的三个特征:

    1. 确定性(集合中的元素必须是确定的)
    2. 互异性(集合中的元素互不相同。例如:集合A={1,a},则a不能等于1)
    3. 无序性(集合中的元素没有先后之分),如集合{3,4,5}和{3,5,4}算作同一个集合。
    展开全文
  • 泛型集合的定义及使用 引入 什么是泛型、为什么要引入泛型、泛型类和泛型方法的使用 实例泛型: ​ 创建对象时,为类所定义的泛型,进行参数化赋值。 类:创建对象时,为类所定义的泛型,进行参数化赋值 接口:...

    泛型集合的定义及使用

    引入

    什么是泛型、为什么要引入泛型、泛型类和泛型方法的使用

    实例泛型:

    ​ 创建对象时,为类所定义的泛型,进行参数化赋值。

    • 类:创建对象时,为类所定义的泛型,进行参数化赋值
    • 接口:实现接口时,为接口所定义的泛型,进行参数化赋值

    静态泛型:

    • 定义在方法的返回值类型前面:、、<T extends Comparable>、<T extends Comparable<? super T>> 可应用在形参列表、返回值两种场景上,不单单可以规范泛型,还可以语义化返回值。
    • 定义在方法的形参列表当中:<?>、<? extends Object>、<? super Integer>,不支持使用& 只能应用在形参列表上,规范泛型。

    1 概述

              一种约束—规范类型(常用名字:E = Elememt、T = Type、K = Key、V = Value),将类型的明确工作提前到对象的创建以及方法调用,防止程序不安全泛型 :将类型的明确工作提前到对象的创建以及方法调用,防止程序不安全;参数化类型、类型安全的集合,强制集合的类型必须一致;

    特点:

    1. 编译时即可检查,而非运行时抛出异常
    2. 访问时,不必类型转换也就是拆箱
    3. 不同泛型之间引用不能相互赋值,泛型不存在多态。(左泛型不可为右父类)

    2 泛型的好处

    1. 将运行时期异常提前到了编译时期;
    2. 在遍历集合时,避免了强制类型转换;
    3. 解决了程序黄色警告线的问题------>提高了程序的安全性;
    public static void main(String[] args) {
    		//创建一个ArrayList集合对象
    		ArrayList<String> array = new ArrayList<String>() ;//后面:泛型推断
    		
    		//添加元素
    		array.add("kaka") ;
    		array.add("hello") ;
    		array.add("java") ;
    		array.add("javaee") ;
    		
    		//遍历
    		Iterator<String> it = array.iterator() ;
    		while(it.hasNext()) {
    			String s = it.next() ;
    			System.out.println(s);
    		}
    	}
    
    • 使用泛型集合时注意类型要保持一致,否则会出现类型转化异常(ClassCastException)

    2.1 ArrayList集合存储自定义对象,加入泛型

    需求:使用ArrayList集合存储自定义对象Student,加入泛型

    1)定义一个学生类

    2)创建集合对象 ArrayList

    3)创建5个学生

    5)将5个学生添加到集合中

    6)创建迭代器

    7)利用迭代器遍历集合

    8)利用get(int index)+size()相结合的方式遍历

    /*
     * 学生类
     */
    public class Student {
    	private String name ;
    	private int age ;
    	public Student() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public Student(String name, int age) {
    		super();
    		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 String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    }
    
    public static void main(String[] args){
    		//创建一个ArrayList集合
    		ArrayList<Student> array = new ArrayList<Student>() ;
    		
    		//创建学生对象
    		Student s1 = new Student("曹操",35) ;//后知后觉
    		Student s2 = new Student("蒋干",25) ;//不知不觉
    		Student s3 = new Student("诸葛亮",30) ;//先知先觉
    		
    		array.add(s1) ;
    		array.add(s2) ;
    		array.add(s3) ;
    		
    		//迭代器
    		Iterator<Student> it = array.iterator() ;
    		while(it.hasNext()) {
    			Student s = it.next() ;
    			System.out.println(s.getName()+"---"+s.getAge());
    		}
    		System.out.println("----------------------------");
    		
    		//普通for循环:get(int index)+size()相结合
    		for(int x = 0 ; x < array.size() ; x ++) {
    			Student s = array.get(x) ;
    			System.out.println(s.getName()+"---"+s.getAge());
    		}
    	}
    

    3 泛型的应用

    泛型主要应用在集合中:

    • 定义在类中
    • 定义在接口中
    • 定义在方法中

    3.1 泛型类

    把泛型定义在类上

    格式:

    • public class 类名<泛型类型1,…>

      泛型类型必须是引用类型

    /*
     * 使用泛型:提高程序的安全性:将泛型定义类上
     */
    public class ObjectTool<T>{
    	//成员变量
    	private  T obj ;
    	
    	//获取功能
    	public T get() {
    		return obj ;
    	}
    	
    	//设置功能
    	public void set(T obj) {
    		this.obj = obj ;
    	}
    }
    
    
    /*
     * 将泛型定义在类上 	测试类
     */
     public static void main(String[] args) {
    			//创建ObjectTool类的对象
    			ObjectTool<String> ot = new ObjectTool<String>() ;
    			
    			//设置数据
    			ot.set("卡卡"); 
    			//获取数据
    			String s = ot.get() ;
    			System.out.println("姓名是:"+s);
    			
    			ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
    			
    			//设置数据
    			ot2.set(28);
    			Integer i = ot2.get() ;
    			System.out.println("年龄是:"+i);
    		}
    

    3.2 泛型方法

    把泛型定义在方法上

    格式:

    • public <泛型类型> 返回类型 方法名(泛型类型 .)
    public class ObjectTool<T>{		
    	//将泛型定义在方法上
    	public <T> void show(T t) {
    		System.out.println(t);
    	}
    }
    
    public static void main(String[] args) {
    		//创建ObjectTool类的对象
    		ObjectTool ot = new ObjectTool() ;
    		ot.show("hello");
    		ot.show(true);
    		ot.show(100);
    		ot.show(12.34);
    	}
    

    3.3 泛型接口

    把泛型定义在接口上

    格式:

    • public interface 接口名<泛型类型1…>

    3.1 实现类已经明确数据类型

    /*
     * 定义在接口上
     */
    public interface Inter<T> {
    	public abstract void show(T t);
    }
    
    /*
     * 测试类
     */
    public class InterDemo {
    	public static void main(String[] args) {
    		//接口多态
    		//第一种
    		Inter i = new InterImpl();
    		i.show("kaka");//kaka
        }
    }
    
    /*
     * 接口子实现类
     */
    public class InterImpl implements Inter<String>{
    
    	public void show(String t) {
    		// TODO Auto-generated method stub
    		System.out.println(t);
    	}
    }
    

    3.2 子实现类没有明确数据类型

    /*
     * 定义在接口上
     */
    public interface Inter<T> {
    	public abstract void show(T t);
    }
    
    /*
     * 测试类
     */
    public class InterDemo {
    	public static void main(String[] args) {
    		//不明确数据类型
    		Inter<Integer> i1 = new InterImpl<Integer>();
    		i1.show(100);//100
    		Inter<String> i2 = new InterImpl<String>();
    		i2.show("kaka");//kaka
        }
    }
    
    /*
     * 接口子实现类
     */
    public class InterImpl<T> implements Inter<T>{
    
    	@Override
    	public void show(T t) {
    		// TODO Auto-generated method stub
    		System.out.println(t);
    	}
    }
    

    4. 高级泛型_通配符

    关于泛型的通配符号:

    • <?>:任意Java类型(Object),可以自定义的类型,或者是JDK提供的任意Java类;
    • <? extends E>:向下限定E类型以及其他子类;
    • <? super E>:向上限定E类型以及其他的父类;
    public class Generic{
    	public static void main(String[] args) {
    		//<?>
    		//创建集合类型Collection集合
    		Collection<?> c1 = new ArrayList<Object>();
    		Collection<?> c2 = new ArrayList<Animal>();
    		Collection<?> c3 = new ArrayList<Dog>();
    		Collection<?> c4 = new ArrayList<Cat>();
    		
    		//<? extends E>
    		Collection<? extends Animal> c5 = new ArrayList<Animal>();
    		Collection<? extends Animal> c6 = new ArrayList<Dog>();
    		Collection<? extends Animal> c7 = new ArrayList<Cat>();
    //		Collection<? extends Animal> c8 = new ArrayList<Object>();错误
    		
    		//<? super E>
    		Collection<? super Animal> c9 = new ArrayList<Object>();
    		Collection<? super Dog> c10 = new ArrayList<Animal>();
    		Collection<? super Cat> c11 = new ArrayList<Animal>();
    //		Collection<? super Animal> c12 = new ArrayList<Dog>();错误
    		
    		
    	}
    }
    class Animal{}
    class Dog extends Animal{}
    class Cat extends Animal{}
    
    
    • 注:在开发过程中,直接在创建集合的时候给定具体的存储类型
      • Collection<String> c = new ArrayList<String>();
    展开全文
  • 文章目录集合什么是集合数组集合类(集合)案例演示集合的主要特征与类型 集合 什么是集合 在定义集合时,我们通常会将集合和数组进行比较。 数组 数组一组相同数据类型数据的集合,可以通过下表对元素进行操作。...

    集合

    什么是集合

    在定义集合时,我们通常会将集合和数组进行比较。

    数组

    数组是一组相同数据类型数据的集合,可以通过下表对元素进行操作。但是数组也存在缺点,它采用固定长度且元素相对操作比较繁琐。

    集合类(集合)

    为了解决数组存在的这些问题,.NET中引入集合对象,其长度可以调整且元素操作简单方便。

    在软件开发过程中,经常需要保存各种数据,因此计算机在处理问题时就需要解决一下3个问题:

    (1)如何方便高效地组织和显示数据

    (2)如何存储数据

    (3)如何对存储的数据进行操作

    前人在思索这些问题的过程中总结了一套解决方式,称之为数据结构。.NET平台封装好了一些常用的数据结构,称之为集合类,简称“集合”。

    案例演示

    下面以客户排队演示数组和与集合的使用。

    首先我们创建一个控制台应用程序,然后添加一个Customer类,代码如下:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace JiHe
    {
        public class Customer
        {
            //定义一个无参的构造方法
            public Customer() { }
            //定义一个有参数的构造方法
            public Customer(string name, int age, string address)
            {
                Name = name;
                Age = age;
                Address = address;
            }
            public string Name { get; set; }
            public int Age { get; set; }
            public string Address { get; set; }
        }
    }
    
    

    接着在Program中来调用构造方法:使用数组来存储对象

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace JiHe
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建两个Customer对象并实例化
                Customer customer_1 = new Customer("张三",18,"北京");
                Customer customer_2 = new Customer("李四", 19, "上海"); 
                Customer customer_3 = new Customer("王五", 20, "深圳");
                //创建一个Customer类型的数组
                Customer[] list = new Customer[2]; //数组长度为2
                //数组下标是从0开始的
                list[0] = customer_1;
                list[1] = customer_2;  
                list[2] = customer_3;
                Console.WriteLine("排队等待的客户有:");
                for (int i = 0; i < list.Length; i++)
                {
                    Console.WriteLine("{0}号:{1}",i+1,list[i].Name);
                }
            }
        }
    }
    
    

    此时运行结果如图所示,
    在这里插入图片描述
    由于数组长度只有2,但是我们添加了3个对象到数组里面去,所以报错。

    因此,当存储一系列对象时,我们就要使用功能更为强大的集合。

    使用集合来存储对象:使用集合类,需要导入System.Collections命名空间

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace JiHe
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建两个Customer对象并实例化
                Customer customer_1 = new Customer("张三",18,"北京");
                Customer customer_2 = new Customer("李四", 19, "上海");
                Customer customer_3 = new Customer("王五", 20, "深圳");
                //创建一个集合对象
                ArrayList list = new ArrayList();       
                list.Add(customer_1);
                list.Add(customer_2);
                list.Add(customer_3);
                Console.WriteLine("排队等待的客户有:");
                //集合类的Count属性用于获取存储对象的个数
                for (int i = 0; i < list.Count; i++)
                {
                    //获取集合中对象必须进行类型转换,将list转换为Customer类型
                    Console.WriteLine("{0}号:{1}",i+1,((Customer)list[i]).Name)       
                }
            }
        }
    }
    
    

    运行结果如图所示,成功运行:

    在这里插入图片描述

    通过这个案例,可以发现,集合相对于数组,最大的优势就是长度可以变化,按需分配。而数组呢,它的长度比较固定。所以当我们在程序中存储一些对象时,建议大家使用集合。

    集合的主要特征与类型

    C#中的集合表示可以通过遍历方式来访问一组对象,其主要特征如下:

    (1)动态地改变大小

    (2)可存储任意类型的对象

    (3)提供一系列操作集合中对象的方法

    C#中的集合提供了一套性能优良、使用方便的类和接口。C#中的集合被定义在System.Collections命名空间中,如ArrayList(数据列表)、Hashtable(字典)、Queue(队列)、Stack(栈)和SortedList(排序列表)等。

    集合 说明
    List 可以像数组一样按索引访问列表,但提供了其他方法来搜索和排序
    Queue 先入先出数据结构,提供了方法将数据项添加到队列的一段,从另一端删除项,以及只检查不删除
    Stack 先入后出数据结构,提供了方法将数据压入栈顶,从栈顶出栈,以及只检查栈顶的项而不删除
    LinkedList 双向有序列表,为任何一端的插入和删除进行了优化,这种集合既可作为队列,也可作为栈,还支持列表那样的随机访问
    HashSet 无序值列表,为快速数据获取而优化,提供了面向集合的方法来判断它容纳的项是不是另一个HashSet 对象中的项的子集,以及计算不同HashSet 对象的交集和并集
    Dictionary 字典集合允许根据键而不是索引来获取值
    SortedList 键/值对的有序列表,键必须实现Icomparable接口
    展开全文
  • vb6.0中文编程数组集合重复判断机制是什么?怎么定义数组不允许出现完全一样两行?能不能禁止数据两行完全一样?
  • 什么叫做多态,条件是什么? 一类事物行为,具有多种表现形式。 条件: 继承或者实现【二选一】 方法重写。 父类引用指向子类对象。 使用多态特性,带来了什么样好处? 增强方法扩展性和复用性。 ...
  • 使用Parcelable 时 遇到有集合定义的时候,为什么一定要进行初始化呢?如图所示: 解析: 因为如果不进行初始化,直接定义private List<Score> scores; 会出现如下错误信息: 应该反序列化过程中集合...
  • 一:集合的推导式 1、用可迭代对象来创建(生成)集合的表达式叫集合推导式 2、语法 {表达式 for 变量 in 可迭代对象 [if 真值表达式]} 注:[]括号里面的部分内容可以省略 示例: L = [2,3,5,7,3,5,7,11] S = {x**2 ...
  • 集合的定义只有一句话: 集合(set)一个无序的不重复元素序列。 重复一遍:集合里边的元素不可重复的并且集合内的元素还是无序的。 如果细细的挖掘,你会发现它还有以下信息: 集合一个可变容器 集合内的...
  • JDK1.7在使用hashmap存储时候,当知道集合大小时候初始化时候,建议指定集合容量大小 为什么呢? hashmap源码中,我们知道hashmap不指定大小时候,初始容量capacity值为16。负载因子为0.75,当我们put操作...
  • python定义集合的问题

    2015-08-08 06:42:06
    网上看了段代码,Python定义集合时每个元素前面加个u是什么意思? ``` lesson = [u'语文', u'数学', u'英语', u'化学', u'物理', u'生物', u'历史', u'地理',] ``` 哪位老师指点一二,谢谢。
  • 一 什么是集合 集合里面的元素不可重复的 s = {1, 2, 3, 4, 1, 2, 3} print(s, type(s)) 如何定义一个空集合 s = { }不能直接表示集合的,表示的字典 集合应用: 列表去重 li = [1,2,3,1,2,3] print...
  • MySQL中究竟什么是数据并且数据库的定义是什么呢? 1.数据: 数据包含很多种类,例如图像、声音、文字、图形以及学生的档案记录等,这些都是对数据的广义理解 2.数据库: 1)数据库又称BataBase(简称DB)大部分是...
  • 集合一般指 list , map ,...不成文规定,如果要返回一个集合 ,那么我就返回一个新 集合对象即可比如 List list=new ArrayList(),不要返回 null类型。这样 进行判断什么的都比较方便了,不需要再判断null了 ...
  • 我已经寻找一个解释在这个背景下是什么意见,以及它是否在番石榴以外使用的术语.这是经常使用here.这个来自Guava的type有它的名字. 我的猜测是,集合的视图是具有相同数据但结构不同的另一集合;例如,当我从java.util....
  • 什么是java集合

    2017-02-11 11:53:17
    1. 集合 1.1. 什么是集合 ...集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解
  • <p>FIRST集合和FOLLOW集合关系 请仔细回顾FIRST集合和FOLLOW集合的定义,以及这两个集合的计算方法,看看这两集合之间是什么关系?有依赖关系吗?</p>
  • 什么是数组的定义

    2020-09-12 20:50:43
    数组的定义形式: 数组的概念: 数组存储同一种数据类型多个元素的集合。也可以看成一个容器。 数组既可以存储基本数据类型,也可以存储引用数据类型。 数组的两种定义格式 格式1:数据类型[]数组名; int[] ...
  • 集合的学习笔记

    2017-03-18 15:50:57
    首先,我们要明白什么是集合,集合的定义是什么: 集合,又称作容器,提到容器,我们不难想到数组,集合与数组不同的是 数组是用来保存基本类型的,而集合是用来保存对象的引用,不可以存放基本类型 集合的长度是...
  • 什么是方法?方法的定义

    千次阅读 2020-08-21 16:53:16
    方法 命名规则: 首字母小写,如果名称由多个单词组成,从第二个单词的开始首字母大写 Java方法语句的集合,它们在一起执行...方法的定义 Java的方法类似于其它语言的函数,一段用来完成特定功能的代码片段,一般
  • 如何判断购物车属性是什么:一个人有年龄,所有人都有,且大家都可能不同 一个购物车示例对象,都放有 商品,可能数量不同。所以商品的集合就是一个购物车属性。总价格也是属性。 方法,改变属性,都是...
  • 什么是集合

    2017-05-27 11:16:17
    一、集合与数组 数组(可以存储基本数据类型)用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。...(这当今较常见的定义) 2.在程序编码中一些包含参数的
  • Java中不是说接口也一种类吗?怎么书上只提操作的集合,不提属性问题呢?一个类不是属性和方法封装体吗?
  • 对方辩友,您方集合的定义是什么? 哈哈,集合是不能精确定义的基本数学概念。这让我想到13武大表演赛打“人是不是万物的尺度”那场陈铭一辩驳论时说:“人尝试定义万物但从未对过。”这场表演赛观赏性极高,建议...
  • C++ 程序可以定义为对象的集合,这些对象通过调用彼此方法进行交互。现在让我们简要地看一下什么是类、对象,方法、即时变量。 对象 - 对象具有状态和行为。例如:一只狗状态 - 颜色、名称、品种,行为 - 摇动、...
  • 如果我们有这样一个需求:定义一个描述类圆,要求圆中数据类型不确定,也就是声名属性时候,属性类型不确定。比如描述类圆中有半径,要求半径可以用int,也可以用double。那么此时数据类型不确定,就...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,480
精华内容 3,792
关键字:

集合的定义是什么