java笔记

来源：互联网发布：java memcached 使用编辑：程序博客网时间：2024/06/04 00:40

JAVA笔记

一、基础数据类型（四种八类）

1.四类：整数型（byte、short、int、long）、浮点型（float、double）、

字符型（char）、逻辑型（boolean）

八种：

byte 1字节 -128～127

short 2字节 -2(15)~2(15)-1

int 4字节 -2(31)~2(31)-1

long 8字节 -2(63)~2(63)-1

float 4字节 -3.403E38~.3403E38

double 8字节 -1.798E308~1.798E38

boolean 不稳定

应用类型（类，数组，接口）

二、创建类名

不能以数字开头、只能以字母，$，下划线开头。

约定规范：以大写字母开头、以驼峰命名法命名。

static 创建的值一开始就被加载到内存。

算数用算法

+ - * / ++ — % ++a 先加一再运算，a++ 先运算再加一

关系运算符

> < >= <= != ==

三、创建变量名

不能以数字开头、只能以字母，$，下划线开头，以小写字母开头。

进制（由字符体系决定）,分堆

变量的定义如：int a=10; int a;（具有作用域）

类型转换（boolean类型除外）

大－－小（强制类型转换）

小－－大（自然转换）

byte，char－－short－－int－－long－－float－－double

程序结构：

顺序，分支，循环

四、key-value:键值对

1.key：可以是变量或者表达式

（但必须是int类型或者兼容int类型的数据，1.7（含）以后可以是string类型的数据）

2.value同key

3.vlaue是无序的（仅代表各种情况）

4.break：跳出，当满足条件，遇到break，则跳出，如果未遇到break，则依次向下执行，直到遇到break

5.default位置不固定，相当于else，当前面的所有情况不满足时执行该代码块

6.default vs break: 即使到程序结束依旧没有break，也不会向上执行default

7.if..else vs switch:

1):当判断条件是某一范围时，则必须使用if..else

2).当判断条件是具体的值类型，分支不多时使用if..else，分支较多时使用switch

switch1.对比的内容均来自同一个变量

2.对比选择的内容不是一个区间，而是某一个确定的值

whitch (固定的参数)

case 固定的值：

代码块

break；

default：

代码块

循环结构

循环是有条件的，不停的执行某个动作。

循环条件：

1.while

定义变量

while（表达式1）｛/／表达式1的返回类型是boolean型。

代码块

表达式2

｝

执行顺序：

定义变量——表达式1－－代码块——表达式2

2.do while

do｛

代码块

表达式1

｝while（表达式2）；

定义变量——代码块——表达式1——表达式2

3.for

for( 1;2 ;3 ){

}

1. 初始化变量2.判断3.改变变量4.代码块

1-－2-－4-－3

数组（相同或相似的数据构成的可被定位的群体）

数组特点：标识符、数组元素、数组下标、元素类型

数组的下标是从0开始的，防止越界。

声明数组分配空间赋值对数组处理

数组的长度不可改变

二维数组是一个以一维数组为元素的数组，可以理解成一个平面。它中间的元素，

都需要用两个来定位。

数组操作过程：遍历（两个for循环嵌套），定位，赋值（静态，动态）

大小写装换：

.toLowerCase();//转成小写

.toUpperCase();//转成大写

例：

String str = "aaaaaBBcccc";

String Upstr = str.toUpperCase();

String Lowstr = str.toLowerCase();

Upstr 的值是 "AAAAABBCCCC"

Lowstr 的值是 "aaaaabbcccc"

面向对象(万事万物皆对象)

面向对象就是采用“模拟现实”的方法设计和开发程序。

用四类八种+String可以保存所有对象的静态属性。

所有的动态特性都是通过过程，改变静态特性的动作，这种动作包含的过程是需要使用到循环，分支等方法的流程控制动作的，而这样的动作，一般只能放置在方法里面.

抽象的过程：

1.发现类；2.发现类的属性； 3.发现类的方法

面向对象的三个特点：

封装，继承，多态（基于一个动作抽象），抽象所产生的东西叫类。

具有相似的属性和行为的集合称为类。所有的属性都应该声明成成员变量。

类是对象的类型，事实上，定义类就是抽取同类实体的共性定义的一种数据类型。

方法（有参，无参）

有参：public 返回值类型方法名（参数列表）{

//方法的主体

}

无参：public 返回值类型方法名(){

//方法的主体

}

方法名的命名规则：以字母、下划线、$开头。后面可以接任意的字母、下划线、$。不能包含java关键字。

方法执行完后会返回一个结果，结果的类型为返回值。

如果方法没有返回值，则返回值类型为void。方法中不能有return返回值。

多个方法不能相互嵌套定义，并且一个方法不能返回多个值。

不能在方法外面直接编写程序逻辑代码。

同一个类中的方法，直接使用方法名调用该方法。

不同类的方法，首先创建对象，再使用“对象名.方法名”来调用。

.equals 判断字符串内容是否相同。

super指的是分类的对象，this指的是当前的对象。

带参方法的个数无论多少个，在使用时只要注意实参和形参一一对应，传递的实际参数值与形式参数的数据类型相同，个数相同，顺序一致。

一个想要被达到的功能被提出的时候，我们要去考虑的第一件事情就是这个里面究竟有几个实体类或者说我们要抽象出来几个类。

（可以在一个类里面，写很多个同名的方法，这些方法要求参数上一定要有些不同，而这些不同不是参数的名字的不同。

参数的不同体现在：参数的个数，类型，顺序来定义名字相同，但不是同一个方法。

以上过程叫方法的重载。返回值是不能影响重载过程的，我们可以理解成为一个新的方法的创建。）

继承：现实生活中的继承是从长辈处获得某些属性或者技能的过程。

代码中的继承是一个定义的比较准确的类从一个定义的比较广泛的类中，获得属性，行为的过程。

继承过程中子类继承了父类的所有的属性，但是父类中的private属性在子类中，不能直接访问。不能直接访问不代表子类没有这个属性，我们可以通过父类中的公共方法来改变子类中的这个属性的值。

子类在创建的过程中必须先调用父类的构造方法。

构造方法的作用是用来创建一个对象并初始化对象，在我们执行一个对象的创建过程中其构造方法是必须要被执行，这一点无论如何都不可避免。例如：Stringstr=new String(); 其中，String()这个东西就是 String这个类的构造方法。

构造方法的特点：

1.其方法名应该与类名一致，这个基本上是我们见过的唯一一个方法名首字母大写的。

2.这个方法是没有返回值类型的。（和一般方法的区别）

3.在我们没有写一个构造方法之前，JAVA会给我们一个默认的，公共的，没有参数的，空的构造方法。

4.构造方法，一般都是放在new关键字后面调用的。

5.当我们完成一个构造一个方法的时候，我们发现系统给我们的默认的构造方法被覆盖了。

6.构造方法是可以像普通的方法一样，传递参数。

7.构造方法一般是用来初始化这个对象用的。

重写和重载的区别：

1.重写必须继承，重载不用。
2.重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。
3.重写的方法修饰符大于等于父类的方法，重载和修饰符无关。
4.重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常

重写的过程中方法名、返回值类型、参数列表中的参数个数，顺序类型必须一致，形参的名字可以不一样。

我们在使用被重写过得方法时，该方法满足就近调用的一个原则，就是如果本类中已经有了该方法则直接使用，如果本类中没有该方法的定义，到这个类的直接父类中寻找该方法的定义，如果找到了，则调用它，如果没有找到，在向父类的直接父类寻找，一直找到java给出的所有类的父类，叫做object。

抽象方法和抽象类

关键字是abstract ，当我们使用abstract修饰方法的时候，这个方法被称为抽象方法，当我们使用abstract修饰类的时候，这个类被称为抽象类。

抽象方法的书写格式访问控制域abstract返回值类型方法名();

抽象类：可以拥有抽象方法的类叫抽象类。

抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

抽象类和普通类的主要有三点区别：

1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

2）抽象类不能用来创建对象；

3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

在其他方面，抽象类和普通的类并没有区别。

里氏替换原则

子类可以扩展父类的功能，但不能改变父类原有的功能。

1.子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法

2.子类中可以增加自己特有的方法

3.当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

static表示静态，我们通过static定义的变量，称之为静态变量,静态变量有一个特点，就是所有的该类的对象共享一个静态变量.

通过static定义的方法，叫做静态方法。

static修饰的方法具有和static修饰的属性一样的特征，都是共享的一个行为，都具有可以不写对象名，直接通过类名进行调用的使用方式。

static在形容内部类时，作用在于内部类可以写静态方法。

内部类基本上具有类的所有特征，内部类可以用static修饰。内部类是写在一个另外的类里面的类。

通过static定义的方法，叫做静态方法

静态方法不能直接调用动态的方法

静态方法也不能直接调用动态的属性

但是动态的方法可以调用静态的方法。

动态的方法是可以调用动态的属性的。

静态的属性在声明是不能用动态的方法进行赋值。

但是静态的属性在声明是可以用静态的方法赋值。

静态代码块是在类的构造方法执行之前，执行的代码。

我们说，所有的static修饰的内容都是放置在静态区的那么，静态代码块也是这样。静态代码块中，是可以加入操作流程的。我们可以理解静态代码块是这个类的对象被创建之前必须执行的一个方法.静态代码块只执行一次。

final这个关键字，是将其修饰的内容设置成任何人不可以修改的内容的意思

final关键字，可以修饰属性，方法和类

在其修饰属性的时候，代表这个属性即使是public，也只能获取里面的值，不能修改里面的值。

在其修饰方法的时候，代表这个方法时不可以被修改的，修改方法，一般出现在重写的过程，就是说这个方法在继承的时候，不可以被重写。

final 在修饰类的时候，代表这个类已经是最终形态了，不可以被任何人修改，即不可以被任何其他的类继承。

接口中没有普通的属性，所有的属性均是常量。接口中没有普通的方法，常见的方法均是抽象的方法，接口中可以定义静态的方法，理解上和常量是一个意思。

普通类

抽象类

接口

可以创建一个对象

不能创建一个对象，如果真的需要使用抽象类创建对象，需使用匿名类的方式

不能有抽象方法

可以有普通方法和抽象方法

只能放抽象方法

可以放置一般属性

只能放置常量

接口命名以I开头+接口名（遵循驼峰命名法）。

接口可以多继承。

1.抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现。

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果。

7、抽象类里可以没有抽象方法。

8、如果一个类里有抽象方法，那么这个类只能是抽象类。

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。

1.抽象类和接口都是用来抽象具体对象的. 但是接口的抽象级别最高。

2.抽象类可以有具体的方法和属性, 接口只能有抽象方法和不可变常量。

3.抽象类主要用来抽象类别,接口主要用来抽象功能。

4、抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的.

一、String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。java把String类声明的final类，不能有类。String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。
二、String类对象的创建
字符串声明：String stringName;
字符串创建：stringName = new String(字符串常量);或stringName= 字符串常量;
三、String类构造方法
1、public String()
无参构造方法，用来创建空字符串的String对象。
1 String str1 = new String();
2、public String(String value)
用已知的字符串value创建一个String对象。
1 String str2 = new String("asdf"); 2 Stringstr3 = new String(str2);
3、public String(char[] value)
用字符数组value创建一个String对象。

1 char[] value = {"a","b","c","d"};2 String str4 = new String(value);//相当于String str4 = new String("abcd");

4、public String(char chars[], intstartIndex, int numChars)
用字符数组chars的startIndex开始的numChars个字符创建一个String对象。

1 char[] value = {"a","b","c","d"};2 String str5 = new String(value,1, 2);//相当于String str5 = new String("bc");

5、public String(byte[] values)
用比特数组values创建一个String对象。

1 byte[] strb = new byte[]{65,66};2 String str6 = new String(strb);//相当于String str6 = new String("AB");

四、String类常用方法
1、求字符串长度
public int length()//返回该字符串的长度

1 String str =new String("asdfzxc");2 int strlength = str.length();//strlength = 7

2、求字符串某一位置字符
public char charAt(int index)//返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

1 String str =new String("asdfzxc");2 char ch = str.charAt(4);//ch = z

3、提取子串
用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:
1)public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

1 String str1 =new String("asdfzxc");2 String str2 = str1.substring(2);//str2 = "dfzxc"3 String str3 = str1.substring(2,5);//str3 = "dfz"

4、字符串比较
1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
2)public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。
3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
4)public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。

1 String str1 =new String("abc");2 String str2 = new String("ABC");3 int a = str1.compareTo(str2);//a>04 int b = str1.compareTo(str2);//b=05 boolean c = str1.equals(str2);//c=false6 boolean d = str1.equalsIgnoreCase(str2);//d=true

5、字符串连接
public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

1 String str ="aa".concat("bb").concat("cc");2 相当于String str = "aa"+"bb"+"cc";

6、字符串中单个字符查找
1)public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
2)public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。
3)public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。
4)public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

1 String str ="I am a good student"; 2 int a = str.indexOf('a');//a = 23 int b = str.indexOf("good");//b = 74 int c = str.indexOf("w",2);//c = -15 int d = str.lastIndexOf("a");//d = 56 int e = str.lastIndexOf("a",3);//e = 2

7、字符串中字符的大小写转换
1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串
2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

1 String str =new String("asDF");2 String str1 = str.toLowerCase();//str1 = "asdf"3 String str2 = str.toUpperCase();//str2 = "ASDF"

8、字符串中字符的替换
1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。
2)public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。
3)public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。

1 String str ="asdzxcasd"; 2 String str1 = str.replace('a','g');//str1 = "gsdzxcgsd"3 String str2 = str.replace("asd","fgh");//str2 = "fghzxcfgh"4 String str3 = str.replaceFirst("asd","fgh");//str3 = "fghzxcasd"5 String str4 = str.replaceAll("asd","fgh");//str4 = "fghzxcfgh"

9、其他类方法
1)String trim()//截去字符串两端的空格，但对于中间的空格不处理。

1 String str =" a sd "; 2 String str1 = str.trim();3 int a = str.length();//a = 64 int b = str1.length();//b = 4

2)boolean statWith(String prefix)或booleanendWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同，重载方法中同时还可以指定比较的开始位置offset。

1 String str ="asdfgh"; 2 boolean a = str.statWith("as");//a = true3 boolean b = str.endWith("gh");//b = true

3)regionMatches(boolean b, int firstStart, String other, int otherStart, intlength)//从当前字符串的firstStart位置开始比较，取长度为length的一个子字符串，other字符串从otherStart位置开始，指定另外一个长度为length的字符串，两字符串比较，当b为true时字符串不区分大小写。
4)contains(String str)//判断参数s是否被包含在字符串中，并返回一个布尔类型的值。

1 String str ="student"; 2 str.contains("stu");//true3 str.contains("ok");//false

5)String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

1 String str ="asd!qwe|zxc#"; 2 String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] ="qwe";str1[2] = "zxc";

五、字符串与基本类型的转换
1、字符串转换为基本类型
java.lang包中有Byte、Short、Integer、Float、Double类的调用方法：
1)public static byte parseByte(String s)
2)public static short parseShort(String s)
3)public static short parseInt(String s)
4)public static long parseLong(String s)
5)public static float parseFloat(String s)
6)public static double parseDouble(String s)
例如：

1 int n = Integer.parseInt("12"); 2 float f = Float.parseFloat("12.34");3 double d = Double.parseDouble("1.124");

2、基本类型转换为字符串类型
String类中提供了StringvalueOf()放法，用作基本类型转换为字符串类型。
1)static String valueOf(char data[])
2)static String valueOf(char data[], int offset, int count)
3)static String valueOf(boolean b)
4)static String valueOf(char c)
5)static String valueOf(int i)
6)static String valueOf(long l)
7)static String valueOf(float f)
8)static String valueOf(double d)
例如：

1 String s1 = String.valueOf(12);2 String s1 = String.valueOf(12.34);

3、进制转换
使用Long类中的方法得到整数之间的各种进制转换的方法：
Long.toBinaryString(long l)
Long.toOctalString(long l)
Long.toHexString(long l)
Long.toString(long l, int p)//p作为任意进制

//System.out.println(str.indexOf("g", 3));//从第3个开始查找

//System.out.println(str.lastIndexOf("g", 8));//从倒数第八个开始查找

//System.out.println(temp.indexOf("jio"));//寻找字符串所在位置

//System.out.println(temp.contains("fg"));//判断子字符串是否存在

//System.out.println(temp.substring(0,temp.length()));//截取字符串

//System.out.println(myName.toLowerCase());//转成小写

//System.out.println(name.toUpperCase());//转成大写

// String used = "I.am.a.handsome.boy!";

// String u=used.replace(".","");//字符替换

// System.out.println(u);

// String[] usedArray =u.split("\\.");// 按照一定规则截断字符串

程序调用自身的编程技巧称为递归（recursion）。递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归的三个条件：1.边界条件2.递归前进3.段递归返回段

当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的好处

Java语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。

这带来了很多好处：

1，类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。

没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

2，消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3，潜在的性能收益。泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。

但是更多类型信息可用于编译器这一事实，为未来版本的 JVM的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。

所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型在使用中还有一些规则和限制：

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上成为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class<?>classType = Class.forName(Java.lang.String);

泛型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子（根据看的印象写的），实现同样的功能，一个使用了泛型，一个没有使用，通过对比，可以很快学会泛型的应用，学会这个基本上学会了泛型70%的内容。

遍历List集合的三种方法

List<String> list = newArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
超级for循环遍历
for(String attribute : list) {
System.out.println(attribute);
}
方法二：
对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
system.out.println(list.get(i));
}
方法三：
集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
System.ou.println(it.next);
}

List使用方法

实例化：List[<数据类型>] list = new ArrayList[<数据类型>]();

获得集合内元素个数：list.size();

添加元素：

默认添加：list.add(e);

指定下标添加（添加后下标后的元素向后挪一位）：list.add(index,e);

删除元素：

返回是否删除：list.remove(e);

直接删除指定下标的元素（只删除找到的第一个相符合的元素）：list.remove(index);

替换元素（替换掉指定下标的元素）：list.set(index,e);

取出元素：list.get(index);

清空集合：list.clear();

判断集合中是否存在某个元素（存在返回true，不存在返回false）：list.contains(e);

对比两个集合中的所有元素：

两个对象一定相等：list.equals(list2);

两个对象不一定相等：list.hashCode() == list2.hashCode();

（两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象。）

获得元素下标：

元素存在则返回找到的第一个元素的下标，不存在则返回-1：list.indexOf(e);

元素存在则返回找到的最后一个元素的下标，不存在则返回-1：list.lastIndexOf(e);

判断集合是否为空（空则返回true，非空则返回false）：list.isEmpty();

返回Iterator集合对象：list.iterator();

将集合转换为字符串：list.toString();

截取集合（从fromIndex开始在toIndex前结束，[fromIndex,toIndex)）：list.subList(fromIndex,toIndex);

将集合转换为数组：

默认类型：list.toArray();

指定类型（objects为指定类型的数组对象，并将转换好的数组赋值给objects数组）：list.toArray(objects)

map 集合类用于存储元素对（称为“键”和“值”），其中每个键映射到一个值。

一个映射不能包含重复的键；每个键最多只能映射到一个值。

HashMap：内部结构是哈希表，不是同步的,允许null为键，null为值。

Iterator:对Collection进行迭代的迭代器。

set是Collection接口的子接口，元素存取是无序的。不可以存放重复元素。

// set接口中的方法和collection一致。

// HashSet：不能保证迭代的顺序与插入的顺序一致。

// LinkedHashSet：迭代输出的顺序与插入的顺序保持一致。

Set是一个接口，使用的实现类是HashSet和TreeSet或者LinkedHashSet boolean add(E e)。

往Set中添加内容，使用的是add方法，Set没有add(index,element);方法。

通过迭代器来遍历Set

// Iterator<String> iterator=mySet.iterator();

// while(iterator.hasNext()){

// System.out.println(iterator.next());

// }

// 修改

// Object[] a = mySet.toArray();

// System.out.println(a[0].toString());

// 移除一个set中的内容，只有一个remove方法，该方法没有被重载

// 即意味着我们没有办法通过角标删除其中的内容。

//mySet.remove("haoshuaia");

//mySet.clear();//清空

System.out.println(mySet.isEmpty());//判断mySet是否为空

一、整理：

看到array，就要想到角标。

看到link，就要想到first，last。

看到hash，就要想到hashCode,equals.

看到tree，就要想到两个接口。Comparable，Comparator。

二、Map与Collection在集合框架中属并列存在

1.Map存储的是键值对

2.Map存储元素使用put方法，Collection使用add方法

3.Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

4.Map集合中键要保证唯一性

也就是Collection是单列集合, Map 是双列集合。

总结:

Map一次存一对元素,Collection 一次存一个。Map 的键不能重复，保证唯一。

Map 一次存入一对元素,是以键值对的形式存在.键与值存在映射关系.一定要保证键的唯一性.

三、Map中常见方法：

1、添加：

1、V put(K key, Vvalue) （可以相同的key值，但是添加的value值会覆

盖前面的，返回值是前一个，如果没有就返回null）

2、putAll(Map<?extends K,? extends V> m) 从指定映射中将所有映射关

系复制到此映射中（可选操作）。

2、删除

1、remove() 删除关联对象，指定key对象

2、clear() 清空集合对象

3、获取

1：value get(key); 可以用于判断键是否存在的情况。当指定的键不存在的时候，返

回的是null。

3、判断：

1、booleanisEmpty() 长度为0返回true否则false

2、booleancontainsKey(Object key) 判断集合中是否包含指定的key

3、boolean containsValue(Object value) 判断集合中是否包含指定的value

4、长度：

Int size（）

四、遍历Map的方式：

1、将map 集合中所有的键取出存入set集合。

Set<K> keySet() 返回所有的key对象的Set集合，再通过get方法获取键对应的值。

2、 values() ，获取所有的值.

Collection<V> values()不能获取到key对象

3、 Map.Entry对象推荐使用重点

Set<Map.Entry<k,v>>entrySet() 将map集合中的键值映射关系打包成一个对象。

Map.Entry对象通过Map.Entry对象的getKey，getValue获取其键和值。

第一种方式:使用keySet

将Map转成Set集合（keySet()），通过Set的迭代器取出Set集合中的每一个元素（Iterator）就是Map集合中的所有的键，再通过get方法获取键对应的值。

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.Set;

public classDemo1 {

public static void main(String[] args) {

Map<Integer, String> map = newHashMap<Integer, String>();

map.put(1, "aaaa");

map.put(2, "bbbb");

map.put(3, "cccc");

System.out.println(map);

// 获取方法：

// 第一种方式: 使用keySet

// 需要分别获取key和value，没有面向对象的思想

// Set<K> keySet() 返回所有的key对象的Set集合

Set<Integer> ks = map.keySet();

Iterator<Integer> it =ks.iterator();

while (it.hasNext()) {

Integer key = it.next();

String value = map.get(key);

System.out.println("key="+ key + " value=" + value);

}

第二种方式: 通过values 获取所有值,不能获取到key对象

1 public static void main(String[] args) {

2 Map<Integer, String> map = new HashMap<Integer, String>();

3 map.put(1, "aaaa");

4 map.put(2, "bbbb");

5 map.put(3, "cccc");

6 System.out.println(map);

7 // 第二种方式：

8 // 通过values 获取所有值,不能获取到key对象

9 // Collection<V> values()

11 Collection<String> vs =map.values();

12 Iterator<String> it =vs.iterator();

13 while (it.hasNext()) {

14 String value = it.next();

15 System.out.println("value=" + value);

16 }

17 }

第三种方式: Map.Entry

public staticinterface Map.Entry<K,V> 通过Map中的entrySet()方法获取存放Map.Entry<K,V>对象的Set集合。

Set<Map.Entry<K,V>>entrySet() 面向对象的思想将map集合中的键和值映射关系打包为一个对象，就是Map.Entry，将该对象存入Set集合，Map.Entry是一个对象，那么该对象具备的getKey，getValue获得键和值。

1 public static void main(String[] args) {

2 Map<Integer, String> map = new HashMap<Integer, String>();

3 map.put(1, "aaaa");

4 map.put(2, "bbbb");

5 map.put(3, "cccc");

6 System.out.println(map);

7 // 第三种方式： Map.Entry对象推荐使用重点

8 // Set<Map.Entry<K,V>> entrySet()

11 // 返回的Map.Entry对象的Set集合 Map.Entry包含了key和value对象

12 Set<Map.Entry<Integer,String>> es = map.entrySet();

14 Iterator<Map.Entry<Integer,String>> it = es.iterator();

16 while (it.hasNext()) {

18 // 返回的是封装了key和value对象的Map.Entry对象

19 Map.Entry<Integer, String>en = it.next();

21 // 获取Map.Entry对象中封装的key和value对象

22 Integer key = en.getKey();

23 String value = en.getValue();

25 System.out.println("key="+ key + " value=" + value);

26 }

27 }

迭代器Iterator接口
1.迭代器接口
Iterable
内置方法iterator()，返回一个新建的Iterator。
如：

public interface Iterable { Iterator Iterator(); }

Iterator 有 hasNext() 和next() 两个方法要实现。 public interface Iterator { booleanhasNext(); Item next(); void remove(); //可选实现 }
2.实现
导入

import java.util.Iterator;

泛型的类，实现Iterable接口 implementsIterable< Item >
实现Iterable的iterator()方法，返回任意定义迭代器类型。
定义迭代器类型 implements Iterator< Item >
实现 hasNext()、 next()、 remove()
3.示例:

public class Stack<Item> implements Iterable<Item> {

public Iterator<Item> iterator() {

return new ListIterator<Item>(first);

}

private class ListIterator<Item> implements Iterator<Item> {

private Node<Item> current;

public ListIterator(Node<Item> first) {

current = first;

}

public boolean hasNext() { return current != null; }

public void remove() { throw new UnsupportedOperationException(); }

public Item next() {

if (!hasNext()) throw new NoSuchElementException();

Item item = current.item;

current = current.next;

return item;

}

4.调用方法
foreach 迭代

for (String s : stack) System.out.println(s);

如果是 int\double 等基本类型，请使用之前的转换关系
5.循环遍历

Iterator i = stack.iterator(); while (i.hasNext()) { String s = i.next(); }

枚举器Enumeration接口

Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法，与Iterator差不多，用来遍历集合中的元素但是枚举Enumeration只提供了遍历Vector和Hashtable类型集合元素的功能，这种类型的集合对象通过调用elements()方法获取一个Enumeration对象然后Enumeratino对象再调用以下方法来对集合中的元素进行遍历。

hasMoreElements()：判断Enumeration对象中是否还有数据

nextElement()：获取Enumeration对象中的下一个数据

实例如下：

Enumeration req = request.getParameterNames();

while (req.hasMoreElements()) {

Object obj = (Object) req.nextElement();

if (obj.toString().trim().equals("LastPage")) {

System.out.println("LastPage \n");

} else if (obj.toString().trim().equals("NextPage")) {

System.out.println("NextPage");

}

Iterator和Enumeration区别
在Java集合中，我们通常都通过 “Iterator(迭代器)”或 “Enumeration(枚举类)” 去遍历集合。今天，我们就一起学习一下它们之间到底有什么区别。
我们先看看 Enumeration.java 和 Iterator.java的源码，再说它们的区别。
Enumeration是一个接口，它的源码如下：

package java.util;

public interface Enumeration<E> {

boolean hasMoreElements();

E nextElement();

}

Iterator也是一个接口，它的源码如下：

package java.util;

public interface Iterator<E> {

boolean hasNext();

E next();

void remove();

}

(01) 函数接口不同
Enumeration只有2个函数接口。通过Enumeration，我们只能读取集合的数据，而不能对数据进行修改。
Iterator只有3个函数接口。Iterator除了能读取集合的数据之外，也能数据进行删除操作。
(02) Iterator支持fail-fast机制，而Enumeration不支持。
Enumeration 是JDK 1.0添加的接口。使用到它的函数包括Vector、Hashtable等类，这些类都是JDK 1.0中加入的，Enumeration存在的目的就是为它们提供遍历接口。Enumeration本身并没有支持同步，而在Vector、Hashtable实现Enumeration时，添加了同步。
而Iterator 是JDK 1.2才添加的接口，它也是为了HashMap、ArrayList等集合提供遍历接口。Iterator是支持fail-fast机制的：当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。

一个程序运行至少一个进程，一个进程里面至少包含一个线程，线程是进程的组成部分。

线程相对于进程而言，很强大了，做到了资源的共享，资源的损耗降低，人为的手工控制程序的运行。

程序:一段静态的代码，一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体，是应用软件执行的蓝本。

进程:是程序的一次动态执行，它对应着从代码加载，执行至执行完毕的一个完整的过程，是一个动态的实体，它有自己的生命

周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映了一个程序在

一定的数据集上运行的全部动态过程。通过进程控制块(PCB)唯一的标识某个进程。同时进程占据着相应的资源（例如包

括cpu的使用，轮转时间以及一些其它设备的权限）。是系统进行资源分配和调度的一个独立单位。

程序和进程之间的主要区别在于：

状态是否具有资源是否有唯一标识是否具有并发性

进程动态有有有

程序静态无无无

进程的基本状态:

1、就绪（Ready）状态

当进程已分配到除CPU以外的所有必要资源后，只要在获得CPU，便可立即执行，进程这时的状态就称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将他们排成一个队列，称为就绪队列。

2、执行状态

进程已获得CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态；再多处理机系统中，则有多个进程处于执行状态。

3、阻塞状态

正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即程序的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态。

三种进程之间的转换图：

线程: 可以理解为进程的多条执行线索，每条线索又对应着各自独立的生命周期。线程是进程的一个实体,是CPU调度和分派的

基本单位,它是比进程更小的能独立运行的基本单位。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之

间可以并发执行。

这里在详细讲解一下Java中的进程和线程的概念。

Java中的线程要经历4个过程

1）创建

创建一个Java线程常见的有两种方式:

继承Thread类和实现Runnable接口这两种方式。

2）执行

线程创建后仅仅占有了内存资源，在JVM管理的线程中还没有该线程，该线程必须调用start方法通知JVM，这样JVM

就会知道又有一个新的线程排队等候了。如果当前线程轮到了CPU的使用权限的话，当前线程就会继续执行。

3）中断

a.JVM将CPU的使用权限从当前线程切换到其它线程，使本线程让出CPU的使用权限而处于中断状态。

b.线程在执行过程中调用了sleep方法，使当前线程处于休眠状态。

c.线程在执行的过程中调用wait方法

d.线程在使用cpu资源期间，执行了某个操作而进如阻塞状态。

4）死亡

死亡的线程不在具有执行能力。线程死亡的原因有二：

a.线程正常运行结束而引起的死亡，即run方法执行完毕。

b.线程被提前强制终止。

阅读全文

2 0