「java集合格式」java集合怎么写

本篇文章给大家谈谈java集合格式，以及java集合怎么写对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java中集合、数组、JSON数据格式这三种东西，它们的书写格式都是怎样的？
• 2、请问在java中如何表示集合？
• 3、java有哪些集合
• 4、java中的集合有几种
• 5、java中的集合分类
• 6、用JAVA将多个集合合并成没有交集的集合

java中集合、数组、JSON数据格式这三种东西，它们的书写格式都是怎样的？

JSON,数组，集合，你可以把它们当做对象，

JSON里面可以包含数组，集合，

集合里面也可以包含数组，JSON

一维数组跟集合没什么区别，数组可是二维，三维

请问在java中如何表示集合？

Java程序设计基础的笔记

『更新时间：2005-3-6 17:21:05』『推荐』『报错』『咨询』『编辑：Jack Chen』『来源：』

Java程序设计基础的笔记

第1课 没有啥好学的，记住下面两点

1、语言的分类 (要懂得举例)：

1）面向对象程序设计语言:Java,C++,smalltalk

2）过程式程序设计语言:C,Pasal

2、语言的分类

1)解释执行语言:如Java，Basic

2)编译执行语言:如C,C++

第2课

1)Java的特点：

简单性、面向对象、分布式()

健壮性(提供自动垃圾回收机制进行内存管理、提供面向对象的异常处理机制、提供严格的类型检查)

平台无关性、解释执行、安全性(不支持指针)、多线程、动态性（是其面向对象设计方法的扩展）。

2)JAVA的平台技术

Java虚拟机、字节码、即用时装入、JIT(Just in Time)及时编译技术

3)Java源文件必须以扩展名.java保存

编译源文件：javac hello.java 执行程序：java hello

第3课 面向对象和开发环境建立

1)面向对象：是一种运用对象、类、继承、封装、聚合、消息传递，多态性等概念来构造系统的一种软件开发方法；追求软件对客观世界的直接模拟；

2)面向对象和客观世界的关系

3)对象：软件系统的基本构成单位；代表问题域中的客观事物的抽象表示，在面向对象中，对象是基本的运行实体，包括属性和行为，将属性和行动封装成一个独立的实体；

4)类：对象之上的抽象，类与类的实例之间关系是抽象与抽象之间的关系，类是创建对象的模板；

5)属性和方法：

属性是描述对象的状态；即表示客观事物的静态特性（数据）；

方法是描述对象的动作；即表示客观事物的动态特性（对数据的操作集合）

6)消息：对象之间利用消息进行通信，具体体现在一个对象调用另一个对象的方法；

7)面向对象语言的三大特点：封装性、继承性、多态性

封装性：指将属性和方法封装在一起，形成一个能动的实体（对象）；

继承性：在不同层次上运用抽象原则，获得类和派生类，源生类可以继承基类的属性和方法。

好处在于：体现层次关系，减少代码数据冗余、增加可重用性；

多态性：向不同的对象发送同一消息，根据对象类的不同而完成不同的行为；

多态是通过继承机制来实现的。

第4节课 建立开发环境(很简单的)

1、配置开发环境

1)安装操作系统：win2000/XP/NT

2)安装JDK1.3或是JDK1.4

3)打开环境变量设置窗口

[开始][设置][控制面板][系统][高级][环境变量]或是[系统变量]

4)配置Path环境变量：值应为c:\Jdk1.3.1\bin --编译路径

5)配置ClassPath环境变量：---类路径

值应为.;c:\jdk1.3.1\lib\tools.jar;c:\jdk1.3.1\lib\dt.jar

6)打开一个命令窗口

7)测试安装是否成功

第5节课 Java语言基础

1)Java的输入输出：字符界面输出、图形界面输出 --本文是前者；

2)记住输入输出的编程语句：

首先要引用import java.io.*;

System.out.println(输出内容);

System.in.read(); 读取一个字符；(字符必须进行初始化，char c=\0)

3)注释方式：三种

// 单行注释：从“//”开始一直到行尾均为注释

/* 一行或多行的注释 */

/** 文档注释 */

第6节课 类型、常量、变量

1)标识符：变量、常量、类、方法的名称都是标识符。

它的组成是有四种：字母、数字，_和$，标识符的开头字符不能以数字开头。

2）Java中标识符需要注意的地方：

保留字或关键字不能作为标识符；

标识符区别大小写；

数字不能开头；

标识符不能含有其他字符；

3)关键字、保留字：请见书上的17页；有印象就可以了。编程时稍注意一点就可以。

4)Java数据类型：基本数据类型和复合数据类型；

基本数据类型：共有8种，分为4小类;分别为逻辑型(boolean)、字符型(char)、整型

(byte,short,int,long)和浮点型(float,double)

复合数据类型：类、数组、接口

5)Java基本数据类型

每一种类型都是有默认值的（整型=0,浮点型=0.0 布尔类型=false,字符类型=\u0000）

size是平台独立的（不运行在硬件上，而是虚拟机上）,各种类型的长度大小：

byte=8;short=16;int=32;long=64;float=32;double=64;char=16;boolean=8

6)变量：指在程序运行过程中可以改变的量，由类型、变量名、变量值三要素组成；

常量：一旦赋了初值，就不能再改变的量，定义常量要使用关键字final.

7)整型常量：十进制整数、八进制整数(以0开头)、十六进制整数(以0x开头)

字符常量：用一对单引号括起来的一个字符。

转义字符：反斜线后面跟上一个字符,\n 换行 \r 回车 \b退格\t 水平制表TAB \0 空

字符串常量：用一对双引号括起来的一个字符序列。

注意：字符串常量和字符常量的区别：

A表示形式不同；B在内存中存储空间不同；C操作不同；D存放两者的变量不同；

8)数组的特点：A、是同类元素的有序集合;B、其元素可用下标访问;C、连续存放;

所有数据类型都可以作为数组的元素，Java的基本工具包(java.util)中有许多类能实现多种类型的数组。

9)数组的定义方法：

A、int[] 数组名 或 int 数组名[] 分配空间时则是在程序中：数组名=new int[10];

B、int[] 数组名=new int[10];

第七章 运算符、流程控制

1)算术运算符：用来定义整型和浮点型数据的算术运算，分为单目，双目和赋值运算符；

单目：

双目：+、-、*、/,%只对整型运算有效

2)关系运算符：、、= = == !=

注意：区分=(赋值)和==(判断)的差别

不能在两个浮点数之间进行==的比较

=、==、!=都能对object reference进行操作

String类支持+和+=

3)逻辑运算符:与、||或、!非

4)位运算符（以二进制位进行运算，操作数和结果都是整型数据）：

~ 位反、｜位域、 位与、^ 位异或、 右移、 左移、 右移，左边空出位填零

5)三目运算符 int x=1,y=2,z=3;int i=x0?y:z; //i的取值是3

6)运算符注意事项：A、运算符的优先级；B、运算符的结合性;具体见P27;

第八节课 流程控制

建议看书本，内容不多

具体结构摘抄如下：

1)if语句：

if {}

或if {} else {}

或if {} else if {} else if {}... else if {} else {};

2)Switch语句：

Swith(条件表达式) {

case 判断值1:语句组1

case 判断值2:语句组2

...

case 判断值n:语句组n

default :语句组n+1;

}

3)for (表达式1;表达式2;表达式3)

循环体；

4)while (条件表达式) 循环体;

5)do ...循环体... while (条件表达式);

6)break; //不带标签;

break label //带标签;

7)continue; //不带标签;

continue label; //带标签;

第9节课 类和对象

1)什么是面向对象？

面向对象是一种新的程序设计范畴，一种新的编程方法；她运用对象、类、继承、封装、聚合、消息传递，多态性等概念来构造软件系统。她追求对客观世界的真实模拟、体现，提高了程序的重用性。

2)什么是对象？

对象是面向对象软件系统中的基本构成单位，代表问题域中的客观事物的抽象表示。

在面向对象中，对象是基本的运行实体，包括属性和行为。将属性和行为封装成一个独立的实体。

3)什么是类？

类是对象之上的抽象，类与对象（类的实例）之间的关系是抽象与具体的关系，类是创建对象的模板；

4)类的一般定义形式

修钸符 class 类名[extends 父类名][implements 接口1,接口2,...] {

修钸符 类型 成员变量1;

修钸符 类型 成员变量2;

修钸符 类型 成员方法1(参数列表){

类型 局部变量

方法体

}

...

}

5)对象如何创建

定义一个对象的引用String s1;

创建一个对象实例：使用关键字new; 例如String s1= new String(字符串内容);

6)对象实例 VS 对象引用

.通过引用操纵对象 .引用不等于对象

.引用保存在堆栈里，对象保存到堆里面

.对于句柄,一种安全的方法就是创建一个引用时就进行初始化

第10课

1)构造函数:通过一个new创建一个类的实例，通过调用构造函数来完成初始化操作；

它的特点：构造函数名字和类完全相同。

构造函数没有返回值，不需要用void

构造函数可以重载。

2)函数重载：使得一个函数名可以对应不同的实现；

实现它的要求：函数参数的类型、函数参数个数、函数参数的顺序不同

仅仅返回值不同是不能实现函数重载的。

在编译时根据函数调用的形式选择适当的重载函数

3)每个类都至少有一个构造方法，如果程序员没有为类定义构造方法，系统会自动为该类生成一个默认的构造方法

默认构造方法的参数列表及方法体均为空。

4)对象的清除

Java引入了新的内存管理机制，由Java虚拟机担当垃圾收集器的工作，你可以任意创建对象而不用担心如何清除它们，垃圾收集器会自动清除它们的。

使用new操作符创建对象后，Java虚拟机自动为该对象分配内存并保持跟踪。Java虚拟机能判断出对象是否还被引用，对不再被引用的对象释放其占用的内存。这种定期寻找不再使用的对象并自动释放对象占用内存的过程称为垃圾收集。

第11课 关键字

1）static关键字：指其属性和方法不需要类的实例化，可以用类直接调用。适用于属性和方法。

类方法可能通过一个类进行调用，而不需要进行实例化出一个对象。

double root=Math.sqrt(453.0);即静态属性和方法可以用类名直接调用，如System.out.println();

2)final关键字：它是最终修shi符，适用于属性、方法、类。

对于基本数据类型、final将值变成一个常数；

对于对象引用时，final将引用变成一个常数，即进行声明时，必须将引用初始化到一个具体的对象，而且永远不能将引用变成指向另一个对象。然而对象本身是可以修改的。

对于数组，类似对象引用，不能重新指向，但数组中的对象并不是常量。

它的作用：A、是防止一个方法的行为在继承期间被覆盖或重写。

B、不希望这个类有子类，所以一个final类中的所有方法都默认为final.

C、

3)数组的定义和初始化 int x[]={5,2,0}

float fArray[]= new float[10];

第12课 构架函数P71

1)什么是访问控制？

在java中，类，属性，方法，接口等都需要访问控制修饰符，它明确指定类，属性，方法，接口的作用域和可见性。即它们可以被程序的哪些部份访问的调用。

2)为什么要使用访问控制符？

它可以使程序结构清晰，严谨。类的使用更加安全，体现封装的概念。

3)访问控制级别：包、类访问控制、成员访问控制

包:

在Java中，将完成相同功能的一组类(.class)组成一个集合，放在一个包中。

通过包，将各种类按照层次组织在一起，使程序的功能结构十分明确，清晰。

如何定义包？

package myFirstPackage

注意：package必须放在一个java文件的最开始。

如何使用一个包中的类？

import java.awt.*

import java.awt.Button

注意：import语句放在package语句之后，任何class定义之前。

包的层次

一个包可由若干个类和子包构成。

当带有包的时候，正确的编译运行程序方式为:java -d .HelloWorld.java

当不带有包的时候，正确的编译运行程序方式为:java HelloWorld.java

第14课(继上节课) 类访问控制符

1)类的访问控制符包含：

.public表示它可能其他所有的类访问和引用，通过它的实例来访问对象的可见属性和方法

.友好的(默认的)表示该类只能被同一个包中的类访问和引用，而不可以被其他包中的类访问和使用。

注：Java中规定，一个.java文件中必须有一个且只有一个public类，因而文件中的其他类只能是友好级别。含有main()方法的类一定是public类

2)成员访问控制符

.public：公有成员，可以被任何类访问，应慎用。

.private：私有成员，只能被访类的方法访问。它提供最高级别的访问。

.protected:保护成员，它能被同一个包中的其他类和任何包中的子类访问。

.友好的(默认的):同一个包那的类都可以访问它；

3)Java应用程序结构

一个可运行的java程序可以包含:多个包、多个.java源文件

一个.java源文件可以包含多个类；

若一个.java源文件包含n个类（class），则编译后生成n个.class文件。

第15课 继承性

1)什么是继承?

通过在不同层次上进行抽象，得到子类（基类）和父类（派生类），子类可以继承父类的非私有属性和方法，即继承基类的特征和能力。

注意：Java不支持多重继承(即不允许一个类有多个直接父类);

2)继承的好处：

继承体现出类的层次关系

减少代码冗余，增加软件复用性

降低软件开发时间，提高软件维护效率

3)继承的一般定义形式

class subclass extends baseclass {....}

第16课

子类的方法不能访问父类的私有成员。

1)子类如何初始化从父类继承而来的属性

a、在派生类的构造函数中没有指明基类的构造函数时，JAVA会自动在第一行加入对基类构造函数的默认调用

super()语句;

b、当基类的构造函数需要参数时，则一定要在派生类的构造函数第一条语句明确调用基类代参数的构造函数

super(agrs)。

c、当基类的构造函数不需要参数时，则在派生类的构造函数中可以不明确的调用super();

2)super和this关键字

super:如果要在子类中调用父类的方法或者访问父类的属性时，则应该是super.methodname();

第17课 多态性

1)什么是多态性？

向不同对象发送同一消息，不同类型的对象产生不同的行为，多态是通过继承机制实现的。

2)什么是重载？

函数名相同，但是函数的参数类型、参数个数、参数顺序不同。

第18课 抽象类

抽象类和抽象方法

1)定义格式：

abstract class instrument{

abstract public void play();

}

注意：1、在一个方法之前加上abstract关键字，且方法体的代码为空，则这个方法就成为抽象方法了。

2、抽象类不能实例化；

3、如果一个类包含一个抽象方法，则这个类必须被声明为抽象类。

2)接口定义

modifier interface interface_name

{varbletype variblename1 ....

returntype method1(params);

}

注意：接口的访问类型同类的访问类型。可以用public或者缺省为包级别的。

接口可以有数据成员，但接口中的数据成员隐藏含是public、static、final。

接口的方法定义是public、abstract，不能是private protected

3)接口使用

1.一个类如果要实现一个接口，就必须实现接口中的所有方法；

2.一个类如果只是实现接口中的部份方法，则一定要标明这个类是抽象类。

3.一般能用接口的就不用抽象类，只有当需要方法定义或成员变量时才用抽象类。

5.接口可以继承，使用关键字extends。

6.一个类如果实现一个继承其他接口的接口，则这个类必须实现这个接口和它的基类接口的所有方法；

7.在Java中，子类和父类只能是单重继承关系，如果要实现多重继承，则需要用到接口。

第19课 Exception

1)对于编程人员，错误分成编译错误和运行错误。

2)什么是Exception?

指在程序运行过程中出现的一些意料之外的错误。

Exception机制：就是用来在发生异常时，告诉程序如何控制自身的运%

java有哪些集合

Java集合主要有四种，分别为：List列表、Queue队列、Set集合、Map映射。

List列表：有序的，可重复的;

Queue队列：有序，可重复的;

Set集合：不可重复;

Map映射：无序，键唯一，值不唯一。

java中的集合有几种

集合类是放在java.util.*；这个包里。集合类存放的都是对象的引用，而非对象本身，为了说起来方便些，我们称集合中的对象就是指集合中对象的引用（reference)。引用的概念大家不会忘了吧，在前边我们讲数据类型时讲的。

集合类型主要有3种：set(集）、list(列表）、map(映射)和Queue（队列）。//队列为jdk5中的加上的

(1) Set

集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。我们知道数学上的集合也是Set这个，集合里面一定是没有重复的元素的。

（2）List

列表（List）的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的Set是不同的。它是链表嘛，一条链肯定有顺序这个顺序就不一定了。

（3）Map

映射（Map），这个在java里不是地图的意思，其实地图也是映射哈。它里面的东西是键－值对（key-value）出现的，键值对是什么呢？举个例子，比如我们查字典，用部首查字法。目录那个字就是键，这个字的解释就是值。键和值成对出现。这样说可以理解吧。这也是很常用的数据结构哦。

（4）Queue

在jdk5.0以前，通常的实现方式是使用java.util.List集合来模仿Queue。Queue的概念通过把对象添加（称为enqueuing的操作）到List的尾部（即Queue的后部）并通过从List的头部（即Queue的前部）提取对象而从 List中移除（称为dequeuing的操作）来模拟。你需要执行先进先出的动作时可以直接使用Queue接口就可以了。

这4个东西，有时候功能还不太完善，需要有些子类继承它的特性。Set的子接口有TreeSet,SortedSet，List的有ArrayList等，Map里有HashMap,HashTable等，Queue里面有BlockingQueue等。我们来看看例子吧：

实践： Set举例

import java.util.*;

public class SetExample {

public static void main(String[] args) {

Set set = new HashSet(); //HashSet是Set的子接口

set.add("one");

set.add("second");

set.add("3rd");

set.add(new Integer(4));

set.add(new Float( 5.0F ));

set.add("second");

set.add(new Integer(4));

System.out.println(set);

}}

List举例：

import java.util.*;

public class ListExample {

public static void main(String[] args) {

List list = new ArrayList();

list.add("one");

list.add("second");

list.add("3rd");

list.add(new Integer(4));

list.add(new Float( 5.0F ));

list.add("second");

list.add(new Integer(4));

System.out.println(list);

}}

Map举例

import java.util.Map;

import java.util.HashMap;

import java.util.Iterator;

import java.io.FileReader;

public class MapExample {

public static void main(String[] args) throws java.io.FileNotFoundException {

Map word_count_map = new HashMap();

FileReader reader = new FileReader(args[0]);

Iterator words = new WordStreamIterator(reader);

while ( words.hasNext() ) {

String word = (String) words.next();

String word_lowercase = word.toLowerCase();

Integer frequency = (Integer)word_count_map.get(word_lowercase);

if ( frequency == null ) {

frequency = new Integer(1);

} else {

int value = frequency.intValue();

frequency = new Integer(value + 1);}

word_count_map.put(word_lowercase, frequency);

}

System.out.println(word_count_map);

}}

Queue举例：

import java.io.IOException;

import java.io.PrintStream;

import java.util.LinkedList;

import java.util.Queue;

public class QueueTester {

public QueueString q; //发现了一个奇怪的语法，这个尖括号是泛型声明

public QueueTester() {q = new LinkedListString();}

public void testFIFO(PrintStream out) throws IOException {

q.add("First");

q.add("Second");

q.add("Third");

Object o;

while ((o = q.poll()) != null) {

out.println(o);}}

public static void main(String[] args) {

QueueTester tester = new QueueTester();

try { tester.testFIFO(System.out);

} catch (IOException e) {

e.printStackTrace(); } }}

java中的集合分类

JAVA集合框架特征介绍(详细的去看看动力节点的java基础大全301集就知道了）

数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。Java提供了几个能有效地组织和操作数据的数据结构，这些数据结构通常称为Java集合框架。在平常的学习开发中，灵活熟练地使用这些集合框架，可以很明显地提高我们的开发效率，当然仅仅会用还是不够的，理解其中的设计思想与原理才能更好地提高我们的开发水平。下面是自己对Java集合框架方面的学习总结。

一、概述

二、Collection接口   1.List   2.Set   3.Queue

三、Map接口   1.HashMap实现原理   2.其它Map实现类

四、其它集合类

五、总结

一、概述

在Java 2之前，Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类，比如Vector，Stack，Hashtable等。这些容器类在使用的过程中由于效率问题饱受诟病，因此在Java 2中，Java设计者们进行了大刀阔斧的整改，重新设计，于是就有了现在的集合框架。需要注意的是，之前的那些容器类库并没有被弃用而是进行了保留，主要是为了向下兼容的目的，但我们在平时使用中还是应该尽量少用。

Java集合框架

从上面的集合框架图可以看到，Java集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection接口又有3种子类型，List、Set和Queue，再下面是一些抽象类，最后是具体实现类，常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap等等。

二、Collection接口

Collection接口是处理对象集合的根接口，其中定义了很多对元素进行操作的方法，AbstractCollection是提供Collection部分实现的抽象类。下图展示了Collection接口中的全部方法。

Collection接口结构

其中，有几个比较常用的方法，比如方法add()添加一个元素到集合中，addAll()将指定集合中的所有元素添加到集合中，contains()方法检测集合中是否包含指定的元素，toArray()方法返回一个表示集合的数组。Collection接口有三个子接口，下面详细介绍。

1.List

List接口扩展自Collection，它可以定义一个允许重复的有序集合，从List接口中的方法来看，List接口主要是增加了面向位置的操作，允许在指定位置上操作元素，同时增加了一个能够双向遍历线性表的新列表迭代器ListIterator。AbstractList类提供了List接口的部分实现，AbstractSequentialList扩展自AbstractList，主要是提供对链表的支持。下面介绍List接口的两个重要的具体实现类，也是我们可能最常用的类，ArrayList和LinkedList。

ArrayList

通过阅读ArrayList的源码，我们可以很清楚地看到里面的逻辑，它是用数组存储元素的，这个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并将当前数组中的所有元素都复制到新数组中。假设第一次是集合没有任何元素，下面以插入一个元素为例看看源码的实现。

1、方法add(E e)向集合中添加指定元素。   public boolean add(E e) {

ensureCapacityInternal(size + 1);  // Increments modCount!!

elementData[size++] = e;        return true;

}2、此方法主要是确定将要创建的数组大小。  private void ensureCapacityInternal(int minCapacity) {        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

ensureExplicitCapacity(minCapacity);

}    private void ensureExplicitCapacity(int minCapacity) {

modCount++;        if (minCapacity - elementData.length 0)

grow(minCapacity);

}3、最后是创建数组，可以明显的看到先是确定了添加元素后的大小之后将元素复制到新数组中。    private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity 1);        if (newCapacity - minCapacity 0)

newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE 0)

newCapacity = hugeCapacity(minCapacity);        // minCapacity is usually close to size, so this is a win:

elementData = Arrays.copyOf(elementData, newCapacity);

}

LinkedList

同样，我们打开LinkedList的源文件，不难看到LinkedList是在一个链表中存储元素。

在学习数据结构的时候，我们知道链表和数组的最大区别在于它们对元素的存储方式的不同导致它们在对数据进行不同操作时的效率不同，同样，ArrayList与LinkedList也是如此，实际使用中我们需要根据特定的需求选用合适的类，如果除了在末尾外不能在其他位置插入或者删除元素，那么ArrayList效率更高，如果需要经常插入或者删除元素，就选择LinkedList。

2.Set

Set接口扩展自Collection，它与List的不同之处在于，规定Set的实例不包含重复的元素。在一个规则集内，一定不存在两个相等的元素。AbstractSet是一个实现Set接口的抽象类，Set接口有三个具体实现类，分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。

散列集HashSet

散列集HashSet是一个用于实现Set接口的具体类，可以使用它的无参构造方法来创建空的散列集，也可以由一个现有的集合创建散列集。在散列集中，有两个名词需要关注，初始容量和客座率。客座率是确定在增加规则集之前，该规则集的饱满程度，当元素个数超过了容量与客座率的乘积时，容量就会自动翻倍。

用JAVA将多个集合合并成没有交集的集合

import java.util.HashSet;

import java.util.Set;

public class Sets {

public static T SetT union(SetT a, SetT b){

SetT set = new HashSetT(a);

set.addAll(b);

return set;

}

public static T SetT intersection(SetT a, SetT b){

SetT set = new HashSet();

set.retainAll(b);

return set;

}

public static T SetT difference(SetT a, SetT b){

SetT set = new HashSet(a);

set.removeAll(b);

return set;

}

public static T SetT complement(SetT a, SetT b){

SetT set = difference(union(a, b), intersection(a, b));

return set;

}

public static void main(String[] args) {

String[] strs1 = {"aaa","bbb","ccc"};

String[] strs2 = {"bbb","ddd"};

SetString set1 = new HashSet();

SetString set2 = new HashSet();

for (String string : strs1) {

set1.add(string);

}

for (String string : strs2) {

set2.add(string);

}

SetString set = Sets.complement(set1, set2);

System.out.println(set);

}

}

采纳吧

java集合格式的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java集合怎么写、java集合格式的信息别忘了在本站进行查找喔。