java无法取消引用int_java

day1

常量：是指在Java程序中固定不变的数据。

类型 含义 数据举例

整数常量 所有的整数 0，1， 567， -9

小数常量 所有的小数 0.0， -0.1， 2.55

字符常量 单引号引起来,只能写一个字符,必须有内容 'a' ， ' '， '好'

字符串常量 双引号引起来,可以写多个字符,也可以不写 "A" ，"Hello" ，"你好" ，""

布尔常量 只有两个值(流程控制中讲解) true ， false 空常量 只有一个值(引用数据类型中讲解) null

变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数据类型 关键字 内存占用 取值范围

字节型 byte 1个字节 -128~127

短整型 short 2个字节 -32768~32767

整型 int(默认) 4个字节 -231次方~2的31次方-1

长整型 long 8个字节 -2的63次方~2的63次方-1

单精度浮点数 float 4个字节 1.4013E-45~3.4028E+38

双精度浮点数 double(默认) 8个字节 4.9E-324~1.7977E+308

字符型 char 2个字节 0-65535

布尔类型 boolean 1个字节 true，false

变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值 。

数据类型 变量名 = 数据值

day 2 数据类型转换、运算符、方法入门

数据转换

范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

浮点转成整数，直接取消小数点，可能造成数据损失精度。int 强制转成 short 砍掉2个字节，可能造成数据丢失。

强制类型转换：数据类型 变量名 = (数据类型)被转数据值；

算数运算符

+ 加法运算，字符串连接运算

- 减法运算

* 乘法运算

/ 除法运算

% 取模运算，两个数字相除取余数

++ 、 -- 自增自减运算

独立运算： 变量在独立运算时， 前++ 和 后++ 没有区别 。

混合运算： 和其他变量放在一起， 前++ 和 后++ 就产生了不同。

变量 前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2

变量 后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b 的结果是1

赋值运算符

= 等于号

+= 加等于

-= 减等于

*= 乘等于

/= 除等于

%= 取模等

比较运算符

== 比较符号两边数据是否相等，相等结果是true。 < 比较符号左边的数据是否小于右边的数据，如果小于结果是true。

> 比较符号左边的数据是否大于右边的数据，如果大于结果是true。

<= 比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。

>= 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。

！= 不等于符号 ，如果符号两边的数据不相等，结果是true。

逻辑运算符

&& 短路与 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算

|| 短路或 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点： 符号左边是true，右边不再运算

！ 取反 1. ! true 结果是false 2. ! false结果是true

三元运算符

布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。

数据类型 变量名 = 布尔类型表达式？结果1：结果2

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。}

修饰符 返回值类型 方法名 (参数列表)｛ 代码... return ; ｝

day3 流程控制语句

if语句格式：

if(关系表达式)｛ 语句体; ｝

if(关系表达式) { 语句体1; }else { 语句体2; }

if (判断条件1) { 执行语句1; } else if (判断条件2) { 执行语句2; }... }else if (判断条件n) { 执行语句n; } else { 执行语句n+1; }

switch：

switch(表达式) { case 常量值1: 语句体1; break; case 常量值2: 语句体2; break; ... default: 语句体n+1; break; }

循环语句

for：

for(初始化表达式①; 布尔表达式②; 步进表达式④){ 循环体③ }

while：

while(布尔表达式②){ 循环体③ 步进表达式④ }

do...while：

do{ 循环体③ 步进表达式④ }while(布尔表达式②);

break：终止switch或者循环

continue：结束本次循环，进行下一循环。

day5 数组

数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

int[] arr = new int[3];

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

int[] arr = new int[]{1,2,3,4,5};

数据类型[] 数组名 = {元素1,元素2,元素3...};

int[] arr = {1,2,3,4,5};

索引： 每一个存储到数组的元素，从0开始，这个自动编号称为数组索引 (index)，通过数组的索引访问到数组中的元素。数组名[索引]

数组的长度属性：数组名.length

day6 类与对象、封装、构造方法

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物

对象：是一类事物的具体体现。对象是类的一个实例(对象并不是找个女朋友)，必然具备该类事物的属性 和行为

成员变量：对应事物的属性 成员方法：对应事物的行为

创建对象：

类名 对象名 = new 类名();

对象名.成员变量；

对象名.成员方法()；

数据类型 默认值

整数(byte，short，int，long) 0

浮点数(float，double) 0.0

字符(char) '\u0000'

布尔(boolean) false

数组，类，接口 null

在类中的位置不同 成员变量：类中，方法外

局部变量：方法中或者方法声明上(形式参数) 作用范围不一样

成员变量：类中 局部变量：方法中 初始化值的不同

成员变量：有默认值 局部变量：没有默认值。必须先定义，赋值，最后使用

封装： 属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

使用 private 关键字来修饰成员变量。

private 数据类型 变量名 ；

提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：

快捷键 alt+ins

this：this代表所在类的当前对象的引用(地址值)，即对象自己的引用。

this.成员变量名；方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

构造方法

1. 如果你不提供构造方法，系统会给出无参数构造方法。

2. 如果你提供了构造方法，系统将不再提供无参数构造方法。

3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

修饰符 构造方法名(参数列表){ // 方法体 } ---public class Student {}；

day7 Scanner类、Random类、ArrayList 类

Scanner类：一个可以解析基本类型和字符串的简单文本扫描器。

调用方法--变量名.方法名();

public int nextInt() ：将输入信息的下一个标记扫描为一个 int 值。

匿名对象：new 类名(参数列表)；

Random类：此类的实例用于生成伪随机数。

java.util.Random ：该类需要 import导入使后使用。

public Random() ：创建一个新的随机数生成器。

public int nextInt(int n) ：返回一个伪随机数，范围在 0 (包括)和 指定值 n (不包括)之间的 int 值。

ArrayList类：大小可变的数组的实现。ArrayList 集合类,让我们可以更便捷的存储和操作对象数据。

java.util.ArrayList ：该类需要 import导入使后使用。

表示一种指定的数据类型，叫做泛型。 E ，取自Element(元素)的首字母。在出现 E 的地方，我们使 用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。

代码如下：ArrayList，ArrayList

public ArrayList() ：构造一个内容为空的集合。

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

ArrayList list = new ArrayList<>();

public boolean add(E e) ： 将指定的元素添加到此集合的尾部。list.add(s1);

public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。list.remove(0)

public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。list.get(0)

public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。 list.size()

以上可以直接通过对象.来调用。比如 对象.size();

基本类型 基本类型包装类(只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可)

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

day8 String类、static关键字、Arrays类、 Math类

String类：代表字符串

1. 字符串不变：字符串的值在创建后不能被更改。

2. 因为String对象是不可变的，所以它们可以被共享。

3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。

public String() ：初始化新创建的 String对象，以使其表示空字符序列。

public String(char[] value) ：通过当前参数中的字符数组来构造新的String。

public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小 写。

public int length () ：返回此字符串的长度。 public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

public char charAt (int index) ：返回指定索引处的 char值。 public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符 串结尾。

public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。

public char[] toCharArray () ：将此字符串转换为新的字符数组。

public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

public String[] split(String regex) ：将此字符串按照给定的regex(规则)拆分为字符串数组

以上可以直接通过对象.来调用。比如 对象.length();

static：它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改 该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

类变量：使用 static关键字修饰的成员变量。

static 数据类型 变量名；

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。调用方式非常简单。

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句 }

Arrays类：类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来 非常简单。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

Math类：类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ：返回 double 值的绝对值。

public static double floor(double a) ：返回小于等于参数最大的整数。

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

以上可以直接通过对象.来调用。比如 对象.abs();

day9 继承、super、this、抽象类

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 { ... }class 子类 extends 父类 { ... }

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰 父类成员变量 super.父类成员变量名。

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

super和this的含义

super ：代表父类的存储空间标识(可以理解为父亲的引用)。

this ：代表当前对象的引用(谁调用就代表谁)。

this.成员变量 ‐‐ 本类的

super.成员变量 ‐‐ 父类的

抽象：父类中的方法，一定被它的子类们重写，我们把没有方法主体的方法称为抽象方法。包含抽象方法 的类就是抽象类。

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体

修饰符 abstract 返回值类型 方法名 (参数列表)；public abstract void run()；

继承抽象类的子类必须重写父类所有的抽象方法。

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

day10 接口，多态

一.接口--它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件。

引用数据类型：数组，类，接口

public interface 接口名称 {

// 抽象方法 // 默认方法 // 静态方法 // 私有方法 }

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类 似继承，格式相仿，只是关键字不同，实

现使用 implements 关键字。 非抽象子类实现接口： 1. 必须重写接口中所有抽象方法。 2. 继承了接口的默认方法，即可以直接调用，也可以重写。

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接 口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

如果父接口中的默认方法有重名的，那么子接口需要重写一次

一个类能继承一个父类，能同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... { // 重写接口中抽象方法【必须】 // 重写接口中默认方法【不重名时可选】 }

二。多态--多态是继封装、继承之后，面向对象的第三大特性

父类类型 变量名 = new 子类对象；

变量名.方法名();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。

左编译 右运行

向上转型 ||多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

父类类型 变量名 = new 子类类型();

向下转型 ||一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

子类类型 变量名 = (子类类型) 父类变量名

变量做类型的校验，

变量名 instanceof 数据类型 如果变量属于该数据类型，返回true。

day11 final、权限、内部类、引用类型

final：不可改变的。 abstract不能与final一起使用

修饰类：public final class 类名称{} 该类不能有子类

方法： public final void 方法名称(){} 该方法是最终方法，不能被覆盖重写

变量: final int num=10； 该局部变量不可改变

成员变量:public class User{ final String USERNAME = "张三"; } 该变量不可变。成员变量有默认值，引用final后必须手动赋值。

权限修饰符

public(公共的)> protected(受保护的)>default(默认的可以不写)>private(私有的)

权限大小： public protected default private

同一类中 √ √ √ √

同一包中(子类与无关类) √ √ √

不同包的子类 √ √

不同包中的非子类 √

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

定义格式： class 外部类 { class 内部类{ } }

内部类可以直接访问外部类的成员，包括私有成员。

外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

出现了重名现象访问外部类成员变量：外部类名称.this.内部类名称

匿名内部类【重点】

是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类定义格式：接口名称 对象名=new 接口名称(){//覆盖重写所有抽象方法};

new 父类名或者接口名(){ // 方法重写 @Override public void method() { // 执行语句 } };

day12 Object,equals，date

java.lang.Object`类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类，那么默认则继承自Object类.

toString方法:public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

equals:指其他对象是否与此对象相等

对象名.equals(对象名1);

比较的是地址值，返回true或者false。

Objects.equals(a,b);objects防止空指针异常

Date:时间和日期，精确到毫秒。

y：年 M：月 d：日 H：时 m：分 s：秒

date.getTime();相当于System.currentTimeMillis()；当前系统时间到1970年1月1号 多少毫秒(中国需要加8个小时)

public Date()`：分配Date对象并初始化此对象，以表示分配它的时间(精确到毫秒)。

public Date(long date)`：分配Date对象并初始化此对象，以表示自从标准基准时间(称为“历元(epoch)”，即1970年1月1日00:00:00 GMT)以来的指定毫秒数。

DateFormat 日期格式化：日期/时间格式化子类的抽象类，我们通过这个类的子类,在Date对象与String对象之间进行来回转换

格式化(日期->文本)

成员方法：String format(Date date); 按照指定模式，把Date日期转化为符合模式的字符串

static void demo02(){

SimpleDateFormat time=new SimpleDateFormat("yyyy-MM-dd");

Date date=new Date();

String d=time.format(date);

}

解析(文本->日期)

Date parse(String source)；把符合模式的字符串，解析为Date日期

static void demo02() throws ParseException {

SimpleDateFormat time=new SimpleDateFormat("yyyy-MM-dd");

Date parse = time.parse("2020-03-06");

System.out.println(parse);

}

DateFormat为抽象类，不能直接使用，所以需要常用的子类`java.text.SimpleDateFormat`。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为：

public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

Calendar 日历类()

字段值 含义

--------------------------------

YEAR 年

MONTH 月(从0开始，可以+1使用)

DAY_OF_MONTH 月中的天(几号)

HOUR 时(12小时制)

HOUR_OF_DAY 时(24小时制)

MINUTE 分

SECOND 秒

DAY_OF_WEEK 周中的天(周几，周日为1，可以-1使用) |

Calendar类是一个抽象类于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，

public static Calendar getInstance()`：使用默认时区和语言环境获得一个日历

public int get(int field)`：返回给定日历字段的值。

public void set(int field, int value)`：将给定的日历字段设置为给定值。

public abstract void add(int field, int amount)`：根据日历的规则，为给定的日历字段添加或减去指定的时间量。

public Date getTime()`：返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。

private static void demo1() {Calendar c=Calendar.getInstance();int i = c.get(Calendar.YEAR);System.out.println(i);}}

public class Demo07CalendarMethod {public static void main(String[] args) {Calendar cal = Calendar.getInstance();cal.set(Calendar.YEAR, 2020); // 2020年}}

public class Demo08CalendarMethod {

public static void main(String[] args) {Calendar cal = Calendar.getInstance();System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日// 使用add方法cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天cal.add(Calendar.YEAR, -3); // 减3年System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; }}

public class Demo09CalendarMethod {

public static void main(String[] args) {Calendar cal = Calendar.getInstance();Date date = cal.getTime();System.out.println(date); // Tue Jan 16 16:03:09 CST 2018}

System类

public static long currentTimeMillis()`：返回以毫秒为单位的当前时间。

例：System.currentTimeMillis()；当前系统时间到1970年1月1号 多少毫秒(中国需要加8个小时)

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)`：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号 参数名称 参数类型 参数含义

1 src Object 源数组

2 srcPos int 源数组索引起始位置

3 dest Object 目标数组

4 destPos int 目标数组索引起始位置

5 length int 复制元素个数

Stringbuilder 字符缓冲区，提高字符串效率

StringBuilder() 构造一个字符串缓冲区，初始容量16个字符。

StringBuilder(String str) 构造一个字符串生成器，初始化为指定字符串

public StringBuilder append(...)`：添加任意类型数据的字符串形式，并返回当前对象自身。

public String toString()`：将当前StringBuilder对象转换为String对象。

包装类

基本类型 对应的包装类(位于java.lang包中)

byte Byte

short Short

int **Integer**

long Long

float Float

double Double

char **Character**

boolean Boolean

装箱

Integer i = new Integer(4);//使用构造函数函数

Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

拆箱

int num = i.intValue();包装对象---->基本数值：

基本类型与字符串之间的转换

public static byte parseByte(String s)`：将字符串参数转换为对应的byte基本类型。

public static short parseShort(String s)`：将字符串参数转换为对应的short基本类型。

public static int parseInt(String s)`：将字符串参数转换为对应的int基本类型。

public static long parseLong(String s)`：将字符串参数转换为对应的long基本类型。

public static float parseFloat(String s)`：将字符串参数转换为对应的float基本类型。

public static double parseDouble(String s)`：将字符串参数转换为对应的double基本类型。

public static boolean parseBoolean(String s)`：将字符串参数转换为对应的boolean基本类型

public class Demo18WrapperParse {public static void main(String[] args) {

int num = Integer.parseInt("100");}}

collection集合：

定义的是所有集合中共性的方法，所有单列结合都可以使用共性方法，没有索引

public boolean add(E e)`： 把给定的对象添加到当前集合中 。

public void clear()` :清空集合中所有的元素。

public boolean remove(E e)`: 把给定的对象在当前集合中删除。

public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。

public boolean isEmpty()`: 判断当前集合是否为空。

public int size()`: 返回集合中元素的个数。

public Object[] toArray()`: 把集合中的元素，存储到数组中。

iterator：迭代器

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

public E next()`:返回迭代的下一个元素。

public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。

public static void main(String[] args) {

// 使用多态方式 创建对象

Collection coll = new ArrayList();

// 添加元素到集合

coll.add("汪星人");

//遍历

//使用迭代器 遍历 每个集合对象都有自己的迭代器

Iterator it = coll.iterator();

// 泛型指的是 迭代出 元素的数据类型

while(it.hasNext()){ //判断是否有迭代元素

String s = it.next();//获取迭代出的元素

System.out.println(s);

}}

增强for循环：

for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码}

public static void main(String[] args) {

int[] arr = {3,5,6,87};

//使用增强for遍历数组

for(int a : arr){//a代表数组中的每个元素

System.out.println(a);

}

}

list接口：有序的集合

1.存取和取出的元素顺序相同 2.允许存储重复的元素 3.有索引，可以使用fir遍历

set接口：

1.不允许存储重复元素 2.没有索引不能for遍历

泛型

是一种未知数据类型，当我们不知道类型的时候，可以使用泛型

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

定义格式：

修饰符 class 类名 { }

含有泛型的方法,定义格式：

修饰符 返回值类型 方法名(参数){ }

含有泛型的接口,定义格式：

修饰符 interface接口名 { }

泛型通配符

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

只能接受数据,不能往该集合中存储数据

day13 数据结构

栈：先进后出

队列：先进先出

数组：查询快，增删慢(地址改变)

链表：查询慢，增删快(地址不变)

链表每一个元素成为一个节点，一个链表但包括一个数据源，两个指针域

自己的地址->数据->下一个节点的地址

单项链表：链表中只有一条链子，不能保证元素顺序。

双向链表:链表中有两条链子，有一条链子专门记录元素顺序，是一个有序的集合。

二叉树：分支不能超过两个

排序树/查找树：在二叉树基础上，元素有大小顺序，左子树小 右子树大。

平衡树：左边孩子和右边孩子相等

不平衡树:左边孩子不等于右边孩子

红黑树：趋近于平衡树，查询速度非常快，查询叶子及节点，最大次数和最小次数不能超过2倍。

缺点：节点可以是红色或者黑色，根节点的是黑色的，叶子节点是空节点黑色，每个

红色的节点子节点都是黑色，任何节点到其每一个叶子节点的黑色节点数相同

List集合

java.util.List 继承collection

有序的集合。有索引的集合，允许存储重复的元素

add(int index,E element) 添加元素到指定

get(int index) 获取指定元素

remove(int index) 移除指定元素 返回的是删除的元素

set(int index,E element ) 索引

ArrayList集合

多线程 数组结构-查询快增删慢

LinkedList集合

底层是链表结构 查询慢，增删快。包含了大量操作首尾元素的方法

注意：使用LinkList的时候不能使用多太

addFirst() 添加元素至第一个

addLast() 添加元素至最后一个

push(E e) 将元素推入列表所表示栈堆，等同于addFirst()

removeFirst() 删除第一个元素并返回第一个元素

removeLast() 删除最后一个元素并返回最后一个元素

pop() 等同于removeFirst()

getFirst() 得到第一个元素

getLast() 得到最后一个元素

isEmpty() 如果列表不包含则返回true

Vector集合

可以实现增长的对象数组，同步的，是单线程，比较慢，被ArrayList取代

Set接口

继承了collection，一个不包含重复元素的collection

不允许存储重复元素，没有索引，没有带索引的方法，不能for循环，可以迭代器和增强for遍历

HashSet接口

此类实现set接口，不允许存储重复元素，没有索引，没有带索引的方法，不能for循环

无序的集合，存储和取出的数据顺序可能不一致，底层是哈希表结构(查询快)

哈希值：是一个十进制的证书，由系统随机给出(就是对象的地址，是一个逻辑地址，是模拟地址，不是实际地址)

public native int hashCode();返回一个哈希值 navite调用本地操作系统方法

哈希表 =数组+红黑树 提高查询速度

存储自定义元素类型，(String ...Person ) 都必须重写

LinkedHashSet

底层是哈希表+一个链表，保证元素有序

可变参数

使用前提：当方法参数列表数据类型已经确定，但是参数的个数不确定

一个方法的参数列表只能有一个可变参数，如果方法参数有多个，可变参数必须写末尾

修饰符 返回值类型 方法名(数据类型...变量名){}

Collections 集合

集合工具类 对集合进行操作

public static boolean addAll(Collection c, T... elements) :往集合中添加一些元素。

public static void shuffle(List> list) 打乱顺序 :打乱集合顺序。

public static void sort(List list) :将集合中元素按照默认规则排序(升序)。

public static void sort(List list，Comparator super T> ) :将集合中元素按照指定规则排 序

被排序的元素必须实现comparable，重写接口中的comparableTo定义排序的规则

comparable和Comparator的区别

comparable：自己和参数比较，自己需要实现comparable接口，重写比较comparableTo规则

Comparator：相当于找到第三方当裁判

例：ArrayList list = new ArrayList();

//采用工具类 完成 往集合中添加元素

Collections.addAll(list, 5, 222, 1，2);

Collections.sort(list, new Comparator() { @Override public int compare(Integer o1, Integer o2) {return 02-01;} });

day14

Map集合

将键映射到值得对象，一个映射不能包含重复的键。每个键最多只能映射到一个值

双列集合，一个元素包含两个值(一个key 一个value)key和value数据类型可以相同可以不同

key不允许重复，value可以重复，value和key一一对应。

HashMap

底层是哈希表，查询速度特别快，无序集合，存储元素和取出元素有可能不一致。

put(k key,v value); 把指定的键与值添加到Map集合当中。key不重复返回null，重复使用新的value替换原有value

remove(Object key); 把指定的键对应的值在Map中删除，返回被删除元素值

get(Object key); 根据指定的键获取对应的值

containsKey(Object key); 判断集合中是否包含指定键

Map aa=new HashMap<>();aa.put("李晨","范冰冰");

keySet(); 把Map集合中所有key取出来存储到Set集合中

for (String aa : map.keySet()) {

System.out.println(aa+map.get(aa));

} 增强for循环 遍历Map集合

entrySet(); 在Map接口中有一个内部接口Entry,当Map集合一旦穿件，就会创建一个Entry对象，用来记录键值

for (Map.Entry ss : map.entrySet()) {

Integer value = ss.getValue();

String key = ss.getKey();

} 增强for循环 遍历Map集合

LinkedHashMap

底层是哈希表(多线程不安全，快)+链表(记录顺序)，有序的集合，存储元素和取出元素顺序一致。

Hashtable集合

双列集合。实现一个哈希表，将哈希表映射到相应值，任何、非null对象都可以作为键或者值,单线程集合，安全，速度慢

of方法

只适用于list接口set接口map接口 不适用于接口的实现类，返回值是一个不能改变的集合，不能再使用add或者put

set接口和map接口在调用of中不能有重复元素