Java基础知识小结(持续更新)_java语言中对象转型的概念-CSDN博客

本文链接：https://blog.csdn.net/Y0156842/article/details/129554972

本文详细介绍了Java编程的基础知识，包括配置Java开发环境、标识符与关键字、数据类型、变量与类型转换、运算符与表达式、选择结构（如if、switch）、循环控制（while、for、do-while）、数组、类和对象、继承、封装、多态、异常处理和反射机制。内容涵盖从基础到进阶的多个方面，适合初学者学习。

摘要由CSDN通过智能技术生成

5. StringBuffer和StringBuilder

8.ArrayList与LinkedList的区别

4.Hashtable与HashMap的区别

一丶Java开发环境

环境变量配置

Windows系统下配置JDK环境变量

(1)安装JDK，我们可以自定义安装目录

(2)右击此电脑，选择属性

(3)点击高级系统设置，选择环境变量

(4)在系统变量中，设置3项属性，JAVA_HOME PATH CLASSPATH

如果已存在则点击编辑，不存在则点击新建

(5)JAVA_HOME选择JDK安装路径，例如E:\Java\JDK

(6)PATH设置为%JAVA_HOME%/bin;

(7)创建CLASSPATH变量，设置为 .;%JAVA_HOME%/lib；

(8)cmd输入命令javac，java，java -version这几个命令，出现东西，说明环境变量配置成功

二丶标识符、关键字、数据类型

1.注释

注释有三种形式：单行注释，多行注释以及文档注释

单行注释：//

多行注释：/*

文档注释：以/**开始，以*/结束

2.分隔符、代码块

以;作为代码结束语句

{}里面的代码叫代码块

3.标识符

在Java中类名，方法名以及变量名称为标识符

标识符命名要求

（1）必须以字母、数字、_或$组成

（2）不能以数字作为开头

（3）不能使用java的关键字和保留字

驼峰命名：第一个单词的首字母如果是大写则是大驼峰命名法,若是小写,则是小驼峰命名法

4.关键字

Java语言中有一些特殊的用途的词称为关键字，关键字不能用作变量名、方法名、类名、包名和参数。

5.基本数据类型

类型的范围

6.常量、变量

6.1变量

变量是Java程序中的基本存储单元，它的定义主要包括变量名、变量类型和变量的作用域三个部分。

变量的声明：数据类型变量名称。例如：int i;

变量的值可以声明时赋值，也可以声明后赋值。

在声明时赋值 int i = 20; 在声明后赋值 i = 20；

全局变量

在类的{}内直接定义的变量，称为全局变量。

全局变量在整个类中都可以使用。

全局变量在创建对象时会自动初始化，并有初始值(默认值)

局部变量

在方法体内部定义的变量，称为成员变量。

成员变量只能在方法体内部使用。

成员变量不会自动初始化，没有默认值，使用之前必须要初始化。

6.2常量

在Java语言中，主要是利用final关键字(在Java类中灵活使用Static关键字)来进行Java常量定义。

一般情况下我们把static与final结合起来声明一个常量，例如：static final int i= 123;

当常量被设定后，一般情况下就不允许再进行更改。

7.类型转换

Java中类型转换分自动类型转换和强制类型转换。

自动类型转换

类型兼容、小类型转换为大类型

byte-->int short--->int int--->long

long--->float float--->double

String--->Object （子类--->父类）

强制类型转换

大类型转换为小类型

int-->byte int--->short long--->int

float--->long double--->float

Object--->String （父类--->子类）

8.方法

package com.xszx;
/**
 * @Author 杨 滢
 * @CreateDate 2023-03-15 15:30
 **/
public class type {
    public static void main(String[] args) {
        byte b = 15;
        short s = 30;
        int i = 126;
        long l = 222L;

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
    }
}

三丶运算符、表达式、选择结构

1.运算符

按操作个数分类：

单目运算符：只需一个操作数参与运算。

双目运算符：需要两个操作数参与运算。

三目运算符：需要三个操作数参与运算

按运算符功能分类：

算数运算符：+ - * / % ++ – –

关系运算符：> < >= <= == !=

逻辑运算符： ! && || & |

位运算符：>> << >>> & | ^ ~

赋值运算符：= += -= *= /=

条件运算符：? ：

其他：instanceof

（1）算术运算符

运算符	运算
+	加
-	减
*	乘
/	除
%	取余
+=	加并赋值
-=	减并赋值
*=	乘并赋值
/=	除并赋值
%=	取余并赋值
++	自增
--	自减

n++ 被使用之后再进行值加1 ++n 值先加1再进行使用

n-- 被使用之后再进行值减1 --n 值先减1再进行使用

（2）关系运算符

关系运算符是两个操作数之间的比较运算

运算符	运算
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

关系运算的结果为布尔类型值，如果关系成立为true，否则为false

关系运算符最常用于if语句和各种循环语句中的控制表达式

（3）逻辑运算符

逻辑运算符是对布尔类型操作数进行的与，或，非，异或等运算，运算结果仍然是布尔类型值

运算符	运算	结果
&	与	左右两边都为true,结果为true，否则为false
\|	或	左右两边只要有一个为true,结果为true，否则为false
^	异或	左右两边不同，结果为true，否则为false
！	非	取反
&&	逻辑与	左右两边都为true,结果为true，否则为false
\|\|	逻辑或	左右两边只要有一个为true,结果为true，否则为false

（4）位运算符

位运算符是对操作数以二进制为单位进行的操作和运算，位运算数的运算对象只能是整型和字符型，结果为整型

（5）赋值运算符

赋值运算符的次序是从右向左的，即先计算表达式的值，再将表达式的赋值给变量。

（6）条件运算符

表达式为：表达式1？表达式2：表达式3 例如： int m =(a>b)?a:b

运算符按照优先级别的高低排序分别是：自加 / 减运算符、算术运算符、关系运算符、逻辑运算符、赋值运算符。

2.表达式

表达式由操作数与运算符组成
操作数可以是常量、变量，也可以是方法
运算符就是数学中的运算符号比如+、-、*、/、%等

3.选择结构

单分支if语句

        语法格式：
        if(条件){
         语句
}

注意事项：

条件的结果只能是布尔类型的值

双分支if语句

        语法格式：
        if(条件){
                语句1
        }else{
                语句2
        }

注意事项：

else子句不能单独使用，它必须是if语句的一部分，与最近的if语句配对使用

多分支if语句

        语法格式：
        if(条件1){
                语句1
        }else if(条件2){
                语句2
        }else if(条件3){
                语句3
        }
         …
        }else{
                语句n
        }

注意事项：

不论多分支if语句中有多少个条件，只会执行符合条件的一个，如果没有符合条件的，则执行else子句中的语句。

多分支switch语句

语法格式：
switch(表达式){
        case 常量 1:
                        语句;
                        break;
        case 常量 2:
                        语句;
                        break;
        …
        default:
                        语句;
                        break;
        }

注意事项：

如果case后没有break语句，程序将继续向下执行，直到switch语句结束或遇到break语句
在同一个switch语句中，两个case常量不允许具有相同的值
- 每个case语句中需要加上break;语句。如果遗漏了break，则会继续进入到下一个case。
- default语句通常放在末尾，可以放在开始，中间或者末尾位置

四丶控制语句

1.while循环

语法结构：

while(条件){

执行的代码块;

}

注意事项：

条件是boolean类型的

当条件为true时则会重复执行其中的代码块。

如果条件为false的话则会停止运行。

2. do while循环结构

语法结构：

do {
语句块;
}while(条件表达式);

至少执行一次循环

3.while 和do while的区别

do while先执行后判断所以它至少执行一次

while先判断条件再执行有可能一次也不执行

所有的循环，都可能出现死循环

4.for循环

语法结构：

for(初始化表达式; 条件表达式; 更新表达式){
       循环体;
       java语句;
       java语句;
       ....
   }

循环是可以嵌套的，包括while和do-while循环

5.break和continue

break：结束本层循环

continue：跳过本次循环，执行循环的下一次

五丶数组

1.概念

数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

2.数组声明

数据类型[] 数组名；

int[] a; //声明一个int类型的数组，名字为a

或数据类型数组名[]；

int a[];

3.数组创建及初始化

int[] a; //声明

数组名=new 数组类型[数组长度];

例如：a=new int[5]; //给数组对象开辟一个长度为5的空间

数组创建的三种方式

int[] nums = new int[5]; //初始化为默认值

int[] nums = {1,2,3,4,5}; //初始化为{}中指定的值

int[] nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值

4.数组的操作

通过下标访问数组元素
通过循环打印输出所有数组元素
可以使用属性length获取数组的长度

5.数组排序

冒泡排序
Arrays.sort()

6.二维数组

初始化：

Int[][] 数组名称 = new int[行数][列数]；

例如：Int[][] arr = new int[3][5];

遍历：

先遍历第一维，然后在内层循环遍历第二维

int[][] a = new int[3][5];
 
for(int i = 0 ; i < a.length ; i++){
 
    for(int j = 0 ; j < a[i].length ; j++){
 
        System.out.println(a[i][j]);
 
    }
 
}

六丶类和对象

1.基本概念

类：有相同特征的事物的集合

对象：对象是类实例化出来的,对象中含有类的属性

2.类与对象的定义和使用

创建类的语法：

                class 类名称 {
                        成员变量/ 实例变量；
                        成员方法；
                }

创建对象的语法：

类名称引用名称 = new 类名称（）

Phone p = new Phone();

例如：

public class PhoneTest {
    public static void main(String[] args) {
        //创建一个实例化对象
        Phone p = new Phone();
        //通过对象来调用实例变量，成员方法
        p.setBrand("小米");
        p.setPrice(998);
        p.call();
        p.sendMessage();
        p.playGame();

    }
}

3.方法

已经写好的代码块，可能会被重复利用多次，就可以把这段代码抽象成方法

创建方法的语法：

public static 方法返回值方法名称（参数类型形式参数列表） {

方法体代码；

[return 返回值]；

}

return

（1）return语句用于明确地从一个方法返回。即，return语句导致程序的执行控制转移回到方法的调用者。

（2）如果return之后还有代码也不会执行。

（3）如果方法的返回类型为void，可以使用return跳出函数，但是不能使用return返回数据。

（4）可以返回对象。

4.方法的调用

调用相同类中的方法：可以直接调用。（本质上是使用this关键字调用）
调用其他类中的方法：对象.方法名

5.构造器(构造方法)

构造方法的作用：开辟内存空间、创建实例、初始化属性值
构造方法的特点：

（1）方法名与类名相同

（2）不能声明返回类型

（3）不能使用return语句

（4）通常为public

6.方法重载

方法重载是指发生在同一个类中，定义了若干个方法名称相同，参数列表不同的(参数类型、参数个数不同)，且与返回值无关的一组方法，叫做方法重载

public class aa{
    //两个整型相乘的方法
    public static int add(int a, int b) {
        return a* b;
    }
 
    //两个整型相加的方法
    public static int add(int a, int b) {
        return a + b ;
    }
 
}

特点：

1、方法名相同

2、形参列表不同：形参的类型/顺序、形参的个数

注意的地方：

1、返回值在区分重载方法时不起作用。修饰符也不起作用

2、当调用重载方法时，Java使用参数的类型和/或数量确定实际调用哪个版本。

七丶面向对象-封装

1.基本概念

封装是面向对象的三大特征之一（封装继承多态）

所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，而是通过该类所提供的方法来实现对内部信息的操作和访问

2.private关键字

是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

3.访问控制符

修饰符	同类	同包	子类	所有包
public	是	是	是	是
protected	是	是	是
默认	是	是
private	是

4.this关键字

this关键字指向的是当前对象的引用

用法：

this.属性名称

指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）。

this.方法名称

用来访问本类的成员方法。

this()

访问本类的构造方法。

()中可以有参数的如果有参数就是调用指定的有参构造。

注意事项：

this() 不能使用在普通方法中只能写在构造方法中。
必须是构造方法中的第一条语句。

5.static关键字

static可以是：

1.变量

如果将一个变量声明为static，就是静态变量了

2.Java静态方法

如果在任何方法上应用static关键字，此方法称为静态方法，静态方法属于类，而不属于类的对象，可以直接调用静态方法，而无需创建类的实例，静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

静态方法的限制：

1.静态方法不能直接使用非静态数据成员或调用非静态方法。

2.this和super两个关键字不能在静态上下文中使用。

3.Java静态块

Java中的静态块主要有两个作用：

用于初始化静态数据成员。
在类加载时在main方法之前执行。

八丶面向对象-继承

1.基本概念

继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。提高代码复用性，减少代码冗余，增强类的功能扩展性。继承的格式子类 extends父类
被继承的类称为父类，继承的类称为子类

2.语法

public class A extends SuperA{

}

3.继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。 Java是单继承模式：一个类只能继承一个直接父类。 Java不支持多继承、但是支持多层继承。 Java中所有的类都是Object类的子类。

4.对象的转型

子类对象赋给父类引用自动转换
父类引用赋给子类引用需要强转，前提：父类引用确实指向了正确的子类对象

5.super关键字

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量访问本类成员变量	this.成员方法(…) 访问本类成员方法	this(…) 访问本类构器
super	super.成员变量访问父类成员变量	super.成员方法(…) 访问父类成员方法	super(…) 访问父类构造器

6.object类

Object 是 Java 类库中的一个特殊类，也是所有类的父类

equals()方法

equals方法默认判断的是地址是否相等，等价于 ==，子类中往往重写该方法，用于判断内容是否相等

tostring()方法

直接打印对象时，默认调用对象的toString()方法

HashCode()方法

返回该对象的哈希码值

当我们重写equals()方法，判断两个对象相等时，最好也同时重写hascode()方法，让相同对象的哈希码值也相同

7.final

如果final修饰变量，变量就是常量，常量不可修改，定义时必须初始化
如果final修饰方法，方法就不能被子类重写
如果final修饰类，类就不能再被扩展，不能再有子类。Java类库中的String、Math就是final类
final修饰的对象引用不可变，内容可变

如果final修饰的常量是基本数据类型，不可以再修改。

如果final修饰的常量是引用类型，不能再将其他对象赋给该引用，但可以使用该引用改变对象内部的属性。

九丶面向对象—多态

1.基本概念

同一个对象，在不同时刻表现出来的不同形态

2.多态的前提

要有继承或实现关系
要有方法的重写
要有父类引用指向子类对象

3.方法重写与方法重载的区别

只有当两个方法的名称和类型签名都相同时才会发生重写。如果不是都相同，那么这两个方法就只是简单的重载关系

重载是在同一个类中，两个方法的方法名相同，参数列表不同（参数类型、顺序、个数），与方法返回值无关

重写发生在父类和子类之间，子类继承父类方法（非构造、final、static修饰的方法）并重写父类方法。
重写规则：

重写方法参数列表、返回值类型必须和父类被重写的方法保持一致
重写方法的访问权限不能低于父类被重写的方法

4.内部类

概念：把类定义在其他类的内部，这个类被称为内部类

分类:根据其所在位置及形式的不同,分为成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类

class Outer {
 
// 成员内部类
 
class Inner {
 
}
 
}

访问成员内部类中的方法：

Outer.Inner inner = new Outer().new Inner();

静态内部类

class Outer {
 
// 静态内部类
 
static class Inner {
 
}
 
}

访问静态内部类中的方法：

Outer.Inner inner = new Outer.new Inner();

方法内部类


 class Outer {
 
// 成员方法
 
public Object show() {
 
// 方法内部类
 
class Inner {

      }
  }
 
}

访问静态内部类中的方法：

Outer outer= new Oute();

System.out.println(outer.showr());

匿名内部类

 new Object(){
 3    void show(){
 4          System.out.println("HHHHHH");                
 5     }
 6 }.show();

十丶面向对象—接口

1.基本概念

简单的说，接口就是一种被规范的标准，只要符合这个标准都可以通用

2.接口的格式

public interface 接口名

3.接口中的属性和方法

（1）接口中所有方法默认是公有的抽象方法

隐式地标识为public、abstract，并且接口中的方法也只允许使用这两个修饰符。

注意，在抽象类中必需使用abstract关键字明确指定方法为抽象方法。

（2）在接口中所有变量默认为公有的静态常量

被隐式地标识为public、static、final。这意味着实现接口的类不能修改它们。同时还必须初始化它们。

4.接口的实现

一旦定义了一个接口，一个或多个类就可以实现该接口。为了实现接口，在类定义中需要包含implements子句，然后创建接口定义的方法

public class Aimplements B{
    }

注意：

（1）实现接口的类，必须实现接口的所有抽象方法，如果只实现了部分抽象方法，该类必须声明为抽象类

（2）一个类可以实现多个接口，实现的多个接口用,隔开

（3）实现接口的类可以同时继承一个父类，必须是先继承后实现

5.接口的实现

接口可以通过关键字extends继承另一个接口，其语法和类继承相同。如果类实现的接口继承自另外一个接口，则该类必需实现在接口继承链中定义的所有方法

6.抽象方法与抽象类

抽象方法

抽象方法是使用abstract修饰的方法。将一个方法声明为抽象方法，如果有继承关系要求子类必须重写该方法

注意：

抽象方法没有方法实现，即没有方法体{}，只有定义
类中如果有抽象方法，该类必须是抽象类，必须使用abstract
对于抽象方法，abstract不能与private、static同时使用

抽象类

类定义中使用abstract修饰的类为抽象类

注意：

从语法上讲，抽象类中可以没有抽象方法，但是没有实际意义
有抽象方法的类必须是抽象类
抽象类不能new对象

7.抽象类与接口的区别

		抽象类	接口
		都可以有抽象方法，都不能实例化，但都可以声明，并能引用子类或实现类对象
	相同点	都可以有抽象方法，都不能实例化，但都可以声明，并能引用子类或实现类对象
不同点	属性变量	可以有变量	只能是静态常量，数据成员必须初始化
	成员方法	可以有具体方法，而且具体方法可以调用抽象方法	如果有方法，全部是抽象方法
	构造方法	有构造方法	没有构造方法
	继承	只能单继承	可以多重实现接口
	扩张性	弱	强

十一丶常用类

1.包装类的分类

Java有八种基本数据类型：byte、short、int、long、float、double、char、boolean

提供了8种对应的包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean

2.使用原因

一方面出于性能方面的考虑，java为数值使用基本类型，而不是对象。基本类型不是对象层次的组成部分，它们不继承Object。

3.自动装箱与自动拆箱

自动装箱

自动装箱就是在需要的时候，基本数据类型会自动被装配成为对应的包装类

创建包装类对象有两种方式：new关键字、valueOf()方法

Integer n = new Integer(3);	            //基本数据类型转为包装类
Integer integer = Integer.valueOf(8);   //基本数据类型转为包装类
int m = n.intValue();		            //包装类型转为基本数据类型

自动拆箱

自动拆箱就是自动装箱的逆过程，在需要的时候，包装类会被自动转换为对应的基本数据类型

Integer  n = 20;		//自动装箱
int m = n;		        //自动拆箱
System.out.println(n);
System.out.println(m);

4.String类

基本概念

在Java中字符串属于对象，，Java提供了String类来创建和操作字符串

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用StringBuffer类或StringBuilder类

字符串长度

可以使用length() 方法来返回string字符串的长度

String类的构造方法

String(); //创建不包含内容的字符串对象

String(char[ ] chars) //通过使用平台的默认字符集解码指定的char数组，构造一个新的String

String(byte[ ] bytes) //通过使用平台的默认字符集解码指定的byte数组，构造一个新的String

String(byte[] bytes,int offset,int length)

//通过使用平台的默认字符集解码指定的byte数组，构造一个新的String

还可以直接使用字符串字面创建String对象：String str = “abc”;

字符串的比较

String类重写了equals()方法，重写后的方法比较两个字符串对象的内容是否相同。

运算符“==”比较两个String引用是否指向同一个String对象

其他比较方法

boolean equalsIgnoreCase(String str) 将此String与另一个String比较，不考虑大小写。

boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始

字符串的连接

String str1 = “abc” ;

String str2 = “def”;

String str3 = “hij”;

(1) String str3 = str1 + str2;

(2)str1.concat(str2);

5. StringBuffer和StringBuilder

区别

StringBuffer类是线程安全的它的方法都有synchronized 关键字修饰，而StringBuilder则不是，即不保证其对象的同步性，在多线程环境中是不安全的
StringBuilder在性能上要比StirngBuffer好一些。

StringBuffer类的常用方法

append()

append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾该方法有多个重载版本，下面是其中的几个：

StringBuffer append(String str)

StringBuffer append(int num)

insert ()

在指定位置插入参数提供的内容，返回修改后的该StringBuffer对象引用。该方法有多个重载版本，下面是其中的几个：

StringBuffer insert(int index, String str)

StringBuffer insert(int index, char ch)

StringBuffer deleteCharAt(int index)

移除指定位置的字符，返回修改后的该StringBuffer对象引用

StringBuffer reverse()

将字符序列逆序，返回修改后的该StringBuffer对象引用

int length()

获取StringBuffer对象的当前长度

6.Date类

Date类封装了当前日期和时间。位于java.util包

常用方法

public Date() //使用当前日期和时间初始化对象

public Date(long date) //参数date为自从1970年1月1日子时经历的毫秒数

long getTime() //返回从1970年1月1日午夜开始已经流逝毫秒数

void setTime(long time) //将日期和时间设置为time所指定的值，time是是自从1970年1月1日午夜开始已经流逝的毫秒数

String toString() //将调用Date对象转换成字符串并返回结果

SimpleDateFormat类

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

1.字符串转日期 2008-07-10 19:20:00 要把它转成日期，可以用

sf.format(date )

日期转字符串假如把今天的日期转成字符串可用

String str = sdf.format(new Date());

jdk1.8日期类

Instant：// 时间戳瞬时时间。
LocalDate： // 同时含有年月日时分秒的日期时间对象本地日期，不包含具体时间, 格式 yyyy-MM-dd。
LocalTime：// 只含有时分秒的时间对象本地时间，不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
- ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差
- LocalDateTime： // 同时含有年月日时分秒的日期时间对象

十二丶集合

1.基本概念

（1）集合是存储其他对象的特殊对象。可以将集合当做一个容器。

（2）集合的相关接口和类位于java.util包中

（3）集合中的接口和类是一个整体、一个体系

2.集合接口

Collection 允许操作一组对象，它位于集合层次结构的顶部

List 扩展Collection，以处理序列(对象列表)

Set 扩展Collection，以处理组，组中的元素必须唯一

注意：

Set类型的集合（实现Set接口的类）称为集，其特点是组中的元素必须唯一

3.Collection接口

Collection接口是构建集合框架的基础，Collection是泛型接口，其声明如下：

interface Collection<E>，其中，E指定了集合将存储的对象类型

集合中只能存储对象，不能存基本类型
使用泛型的优点是在编译时可以检查元素的类型，从而更加安全

4.List接口

List接口扩展了Collection，并且声明了存储一连串元素的集合的行为。索引从0开始，通过它们的位置插入或访问元素。列表可以包含重复的元素

声明：interface List<E>

5.Set接口

Set接口定义了组/集/集合(set)。它扩展了Collection接口，并声明了不允许重复元素的集合的行为。如果为集合添加重复的元素，add()方法会返回false

声明：interface Set<E>

6.Arraylist类

ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组

ArrayList长度取默认值 10

7.LinkedList类

LinkedList类实现了List、Deque以及Queue接口。它提供了（双向）链表数据结构

8.ArrayList与LinkedList的区别

（1）ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念

（2）对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针

（3）对于新增和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。

（4）LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等

9.HashSet

HashSet类实现了Set接口。该类在内部使用哈希表存储元素

哈希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此

HashSet默认容量是16

10.Set与List的区别

（1）Set中的元素无序不能重复，List中的有序元素可以重复

（2）List有索引（下标）的概念，Set没有索引的概念

（3）对于Set表示的集合，通常是遍历操作，没有get()和set()方法

11. Vector类

Vector类实现了动态数组，与ArrayList类似，也实现List接口。但有如下区别：

Vector实现同步，线程安全。ArrayList没有实现线程安全

Vector性能比ArrayList低

Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%

十三丶集合的遍历

1.Iterable接口

实现了Iterable接口的类是可以遍历的。因为Iterable接口是Collection接口的父接口

Iterable接口只定义了一个方法：

Iterator<T> iterator() //返回迭代器对象

2.Iterator接口

Iterator接口描述了迭代器的行为，所有迭代器类都必须实现该接口，该接口定义了以下方法：

boolean hasNext() 如果迭代还有更多的元素则返回true

T next() 返回下一个元素

void remove() 删除迭代器返回的元素

3.ListIterator接口

只有实现了List接口的集合类才提供了ListIterator迭代器

List接口提供以下两个方法用于获取列表集合的列表迭代器：

ListIterator<E> listIterator() 该迭代器从列表的开头开始

ListIterator<E> listIterator()(int index) 该迭代器从index所指定的位置开始

4.迭代器的使用

为了使用迭代器遍历集合的内容，需要以下步骤：

通过调用集合的Iterator()方法，获取指向集合开头的迭代器

建立一个hasNext()调用循环。只要hasNext()返回true，就循环迭代

在循环中，通过调用next()获取每个元素

5.增强for循环

如果不修改集合的内容，也不以反向获取元素，使用for-each版的for循环遍历集合通常比使用迭代器更方便

6.迭代器与增强的for循环之间的区别

使用迭代器遍历集合时，可以调用Iterator.remove()方法删除集合中元素，使用增强的for循环遍历集合时，不能删除集合中的元素

可以使用增强的for循环遍历数组，但是数组不支持迭代器

使用增强的for循环遍历基本类型的数组时，只能使用数组元素，而不能修改数组元素

7.Collections工具类

Collections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList

十四丶Map集合

1.基本概念

Map是一个接口，我们不能直接创建对象，可以通过多态的形式创建对象
Map中一个元素包含两个值（一个key，一个value）
Map中的元素，key不允许重复，value可以重复

Map实现常用的一般有两种，一是HashMap，另一个是TreeMap

2.Map集合的获取功能

方法名	说明
get(Object key)	根据键获取值
keySet()	获取所有键的集合
values()	获取所有值的集合
entrySet()	获取所有键值对对象的集合

3.Map遍历演示

//返回此映射中包含的映射关系的 Set 视图
        Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
        //遍历输出 hashmap 里面的数据
        System.out.println("获取hashmap中所有的数据");
        for (Map.Entry str :entries) {
            System.out.print(str.getKey()+"\t");
            System.out.print(str.getValue());
            System.out.println();
        }