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中不能有重复元素

表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页