Java知识总结

基本数据类类型存的是数值本身，而引用类型变量在内存放的是数据的引用，并不是数据本身，引用类型变量是以间接方式去获取数据。引用类型变量都属于对象类型，如：数组、类、字符串等都属于引用类型变量。所以，引用类型变量里面存放的是数据的地址。

常量：用final修饰（在变量的前面加上一个final）

final 数据类型 常量名称=值

final 数据类型 常量名称1=值1，常量名称2=值2

final

修饰变量，只能被赋值一次，赋值后不再改变

修饰方法：final不能被子类方法覆盖，但可以被继承

修饰类：final类不能被继承，没有子类，final类中所有方法都是final的（如String类）

Instanceof运算符：该运算符是一个二目运算符，左面的操作元是一个对象，右面的操作元是一个类，当左面的对象是右面的类或子类创建的一个对象时，结果为true

声明数组格式：

数组的元素类型  数组名 []    例int a[]

数组的元素类型[] 数组名int [] a

声明数组后还必须为数组分配内存空间格式

数组名字=new 数组元素的类型[数组元素的个数]；

float boy;

boy=new float[4]

声明数组和创建数组可以一起完成

Float boy=new float[4]

类：将实物共有的属性和行为抽取出来，对像是类的实例。

类中方法的定义注意思考方法的类型 方法的名字、方法的参数。例如：人吃饭无返回值没有参数void eat(){  }无返回值使用return语句的作用使程序返回操作系统（及终止程序）

如果局部变量与成员变量的名字相同则成员变量被隐藏，即这个成员变量在这个方法内暂时失效。如果想要使用这个成员变量则要使用关键字this，（区别后面的继承，子类父类成员变量名相同用super）在声明成员变量的时候可以同时赋予初值，但是不可以在类体中有单独的赋值语句（类体中不可以有变量的声明和方法的定义以外的其他语句）因为对成员变量的操作只能放在方法中。Public class Peison{

Int age;

age=10;错 单独的赋值语句

float height =1.8f;对

double weight;

void eat(){

weight=10; 对，在方法内赋值

}

}

构造方法的名字必须与它所在的类名完全相同，而且没有类型，但可以加权限修饰

Person(int age){this.age=age}

对象的创建：Person zhangsan=newPerson(10); 10代表年龄的值

对象不仅可以操作自己的变量改变状态，而且能调用类中的方法产生一定的行为，通过使用“.”运算符，对象可以实现对自己变量的访问和方法的调用。（P64）

操作变量：对象.方法   操作方法   对象.方法

分配给对象的变量称作对象的实体注意:1.避免使用空对象（dyy=null）（没有实体的对象称作空对象），空对象不能使用，既不能让一个空对象去调用方法产生行为

dyy=null;   dyy.age; 就会产生空指针错误

参数传值：方法中最重要的一部分就是方法的参数，参数属于局部变量，当对象调用方法时，参数被分配内存空间，并要求调用者向参数传递值，及方法被调用时，参数变量必须有具体的值。

可变参数：public void （int…x）

public static void main(String[]args) {

       Computer c1 = new Computer();

       // 方法的调用

       int result = c1.getSum(123, 345, 567);

       System.out.println("result:" + result);

    }

    public int getSum(int... x) {

       int sum = 0;

       for (int i = 0; i < x.length; i++) {

           sum = sum + x[i];

       }

       return sum;

    }

}

 

实例成员类成员：

在声明成员变量的时候，用关键字static修饰的变量称作类变量，否则称为实例变量（类变量也成称为static变量、静态变量）

Class Dog{

float x;  //实例变量

static int y;//类变量}

快速创建set get方法右键-àSource-àGenerate Getters and Setters-à选中要创建两个方法的变量---》ok

可以通过类名直接调用类变量与类方法

类方法不可以操作实例变量，因为在还没有创建对象时已经为类变量分配了内存空间，还未给实例变量分配内存空间，所以类方法不能操作实例变量

当用子类的方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了内存，而且父类的成员变量也都分配了内存空间。

子类的继承：子类和父类在同一个包中，子类继承了父类中不是private的成员变量和方法（包括友好型的），子类和父类不在同一个包中子类继承了父类中的protected和public访问权限的成员变量和方法（友好型和private的未被继承）

子类不继承父类的构造方法，因此子类在其构造方法中需使用super来调用父类的某个构造方法，而且super必须是子类构造方法中的头一条语句。

成员变量的隐藏和super关键字：成员变量的隐藏，当子类和父类的成员变量同名时，此时子类调用的是子类中的那个成员变量，父类中的成员变量被隐藏。

方法的重写：(可以隐藏已继承的方法，又称方法的覆盖)子类定义一个方法，这个方法的类型和父类方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数的个数、参数的类型和父类的方法完全相同

 

子类继承的方法只能操作子类继承和隐藏的成员变量，子类新定义的方法可以操作子类继承和子类新声明的成员变量，但无法操作子类隐藏的成员变量（需使用super）

重写方法既可以操作继承的成员变量、调用继承的方法，也可以操作子类新声明的成员变量、调用新定义的其他方法，但无法操作被子类隐藏的成员变量和方法。

重写的语法规则：

1. 如果子类可以继承父类的某个实例方法，那么子类有权力重写这个方法

2. 重写的注意：重写父类的方法时不可以降低方法的访问权限，但可以提高访问权限。

在子类中引用被子类隐藏的成员变量和方法时，可以使用关键字super。例super.x super.play()

对象的上转型对象：假设A类是B类的一个父类。当用子类创建一个对象时并把这个对象的引用放到父类的对象中时，此时这个父类的对象就称之为子类创建的对象的上转型对象，例

A a;

B b=new B();

a=b;

或者

A a;

a=new B();

或者

A a= new B();

 

只能调用继承或隐藏的变量，继承或重写的方法（注：新增的变量和方法都不能被调用）（父类中的变量和方法不一定全被继承）

区别父类的对象 ：父类的对象只能调用自己的成员变量和方法（无继承可言）

可以将对象的上转型对象再强制转换到一个子类的对象，这时，该对象又具备了子类所有的属性和功能。

Car car=newFireCar();

FireCarfireCar=(FireCar)car;

对象的上转型对象的作用：（继承与多态）

多态：是指父类的某个实例方法被其子类重写时，可以各自产生自己的功能行为

抽象类：1.和普通类相比，abstract类可以有abstract方法，也可以有非abstract方法

2.对于abstract方法，只允许声明，不允许实现（没有方法体）,而且不允许使用final和abstract同时修饰一个方法或类也不允许使用static修饰abstract方法，即abstract方法必须是实例方法。

Abstract intgetMax();

 

3.对于abstract类（就是用来被继承），只能声明，不能使用new运算符创建该类的对象，(因为抽象类里面的抽象方法没有方法体，调用无意义，而里面的非抽象方法，未来都是由子类共有)如果一个非抽象类是某个抽象类的子类，那么它必须重写父类的抽象的方法，给出方法体（这就是为什么不允许使用final和abstract同时修饰一个方法或类的原因）

4.Abstract类也可以没有abstract方法（无意义了，因为抽象类就是为了装载抽象方法的）

5.如果一个abstract类是abstract类是abstract类的子类，他可以重写父类的abstract方法，也可以继承这个abstract方法

6.Abstract类的对象作上转型对象

可以使用abstract类声明对象，尽管不能使用new运算符创建该对象，但该对象可以成为其子类对象的上转型对象，那么该对象就可以调用子类重写的方法。

A a;

B b=new B();

一个类除了object类的声明中没有extends关键字，这个类被系统默认为是object的子类

Class A 与class A extends object等价

（对象的上转型对象为了多态，用抽象方法和抽象类实现多态）引出面向抽象的编程

所谓的面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面象抽象类，即所设计类中的重要数据是抽象类声明的对象，而不是具体类声明的对象。（Demo25,Abstract）

 

接口：抽象的最高境界，Java不支持多继承（is-a），让代码更加的强壮，更符合实际（一个类只能有一个父类除了object类）（利用接口解决，不会造成多余的浪费）

使用interface定义一个接口：

接口体中包含常量的声明（没有变量）和方法的定义两个部分，接口体中只有抽象方法，没有普通方法，而且接口体中所有的常量的访问权限一定都是public（允许省略public final修饰符），所有的抽象方法的访问权限一定都是public（允许省略public，abstract修饰符）

Interface Test{

Public final int MAX=100;//等价于int MAX=100；

Public abstract voidadd();//等价于void add();

Public abstract floatgetSum(float x,float y);

}

类通过关键字implements声明自己实现一个或多个接口，如果实现多个接口，则用逗号隔开接口名

ClassA implementsPrintable,Addable

有继承和实现的写法

Class Dog extends Animalimplements Eatable,Sleepable

接口回调：指可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法（和上转型对象很相像）

接口的多态：把实现接口的类的实例的引用（对象的创建后，该接口就可以回调类重写的接口的方法。

由接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式，那么接口变量在回调接口方法时就可能具有多种形态。(Demo27)

 

接口和abstract类的比较：

Abstract类中可以有非abstract方法，接口不可以

2、接口中只可以有常量不能有变量，而abstract类既可以有常量也可以有变量

面向接口编程：面向接口去设计程序，可以通过接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。

使用接口设计程序的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。（与面向抽象的编程类似）

 

内部类：类可以有两种重要的成员:成员变量和成员方法，实际上Java还允许类可以有一种成员：内部类

Java中支持在一个类中声明另一个类这样的类称为内部类，而包含内部类的类称为内部类的外嵌类，内部类的外嵌类的成员变量在内部类仍然有效，内部类的方法也可以调用外嵌类的方法。

内部类的类体不可以声明类变量和类方法，外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。（Demo28）

匿名类：与子类相关的匿名类，与接口相关的匿名类(两者用法相同)

匿名类可以使多态更加灵活，简化代码

假如没有显示的声明一个类的子类，而又想用子类创建一个对象，如何实现？

Java允许我们直接使用一个类的子类的类体创建一个子类的对象，也就是说创建子类的对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类（Demo29）匿名类一定是一个内部类。

异常类：就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。

异常对象可以调用以下方法得到或输出有关异常的信息demo30(自定义异常类)

Public String getMessage()；

Public voidprintStackTrace()；

Public String toString()；

Java使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch
语句的try部分，将发生异常后的处理放在catch部分。

Try{

    包含可能发生异常的语句

}

Catch（ExceptionSubClass1 e）{

…

}catch(ExceptionSubClass2e){

…

 

}

常用实用类：

String类：常用的方法 七大方法（Demo31）

String string = "Hello World";

       Stringstring2 = "HelloWorl";

       //获得字符串的长度

       int len = string.length();

       System.out.println(len);

       //比较两个字符串是否相同

       boolean a = string.equals(string2);

       System.out.println(a);

       //比较字符串前缀（后缀）与指定的字符串是否相同（也可以指一个文件的前缀后缀）

       boolean b=string.startsWith("He");

       System.out.println(b);

       boolean c=string.endsWith("d");

       System.out.println(c);

       //判断当前字符串对象是否含有参数指定的字符串s

       boolean d=string.contains("He");

       System.out.println(d);

       boolean e=string.contains(string2);

       System.out.println(e);

       //从当前字符串的开头检索字符串s（“e”）,并返回首次出现s的位置

       int f=string.indexOf("e");

       System.out.println(f);

       //"l"要检索的字符串，从下标2开始检索

       int g=string.indexOf("l", 0);

       System.out.println(g);

       int h=string.lastIndexOf("l");

       System.out.println(h);

//获得当前字符串的子串

       Stringstring3=string.substring(1,3);

       System.out.println(string3);

       //得到一个string去掉前后空格的字符串对象

       Stringstring4=string.trim();

       System.out.println(string4);

String下：字符串与基本数据类型的转换

Java.lang包中的Integer类调用其类方法

 public static int parseInt(Strings)可以将由“数字”字符组成的字符串，如“12345”，转换为int型数据。

类似的使用java.lang包中的Byte,Short,Long,Float,Double类调相应的类方法可以将“数字”字符组成的字符串，转换为相应的基本的数据类型。

可以使用String类的类方法public static String valueOf(byten)等将形如123、123.21等数值转化为字符串

String string="1234";

       int a=Integer.parseInt(string);

       System.out.println(a);

       String string2="12.34";

       double b=Double.parseDouble(string2);

       System.out.println(b);

       int c=123456;

       String string3=String.valueOf(c);

       System.out.println(string3);

字符串与字符数组和字节数组的转换

字符串与字符数组

1.String类的构造方法

String（char[]）和String（char[],int offset,int len）//分别用字符数组中的全部字符和部分字符创建字符串对象

  char[] a={'a','b','c'};

   Stringstring=new String(a);

   System.out.println(string);

2.将字符串中的全部字符放在一个字符数组的方法：

Public char[] toCharArry()

      String string="hello world";

         char[] a=string.toCharArray();

         System.out.println(a);

         //遍历字符数组

         for(int i=0;i<a.length;i++){

            System.out.println(a[i]);

         }

//输出结果

         hello world

         h

         e

         l

         l

         o

          

         w

         o

         r

         l

         d

 

字符串与字节数组：

String(byte[])用指定的字节数组构造一个字符串对象

String (byte[],int offset,int length)用指定的字节数组的一部分，即从数组的起始位置offset开始取length个字节构造一个字符串对象

Public byte[] getBytes()方法使用平台默认的字符编码，将当前字符串转化为一个字节数组

Publicbyte[]getBytes(String charseName)使用参数指定字符编码，将当前字符串转化为一个字节数组

与字符数组实现的一样

String string =newString(b,0,count);(b 为字节数组)

String string="hello";

      byte[] b=string.getBytes();

      for(int i=0;i<b.length;i++){

         System.out.println(b[i]);

常用实用类StringBuffer类（demo32）

StringBuffer类有三个构造方法

1.  StringBuffer()

2.  StringBuffer(int size)

3.  StringBuffer(String s)

使用第1个无参数的构造方法创建一个StringBuffer对象，那么分配给该对象的实体的初始容量可以容纳16个字符，当该对象的实体存放的字符序列的长度大于16时，实体的容量自动的增加，以便存放所增加的字符

使用第2个构造方法创建一个StringBuffer对象，那么可以指定分配给该对象的实体的初始容量为参数size指定的字符个数，当该对象的实体存放的字符序列的长度大于size个字符时，实体的容量自动的增加，以便存放所增加的字符。

使用第3个构造方法创建一个StringBuffer对象，那么可以指定分配给该对象的实体的初始容量为参数字符串s的长度额外再加16个字符，当该对象的实体存放的字符序列的长度大于size个字符时，实体的容量自动的增加，以便存放所增加的字符。

Strngbuffer的常用方法：

1.  StringBuffer append(String)将一个字符串对象追加到当前StringBuffer

StringBufferappend(int n)将一个int型数据转化为字符串对象后再追加到当前StringBuffer中

StringBufferappend(Object 0)将一个Object对象的字符串表示追加到当前StringBuffer中 类似的还有

StringBufferappend(long n) StringBuffer append(boolean n) StringBuffer appendfloat n) StringBufferappend(double n) StringBuffer append(char n)

2.  public char charAt(int n)//得到参数n指定位置的单个字符

public void setCharAt(int n,char ch)//替换位置n处的字符用ch指定的字符

3.  StringBuffer insert（int index，String str）//将参数str指定的字符串插入到参数index指定的位置

4.  Public StringBuffer reverse（）将该对象实体中的字符翻转

5.  StringBuffer delete（int startIndex，int endIndex）从当前stringBuffer对象的实体中的字符串中删除一个子字符串

DeleteCharAt(int index)//删除index处的一个字符

6.  StringBuffer replace（int startIndex，int endIndex,String str）//将当前stringbuffer对象实体中的一个字符串用参数str指定的字符串代替

//增强for循环

public class ForArray

{

        public staticvoid main(String[] args)

        {

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

               for(int a:arr)

               {

                       System.out.print(a);

               }

        }

}

 

变量a就是为了存放每次遍历得到的值       

for (循环变量类型循环变量名称 :要被遍历的对象) 循环体

     例子中，

       1.arr就是为要被遍历的对象,可以是数组，集合

       2.循环变量类型就是这个arr数组的数据类型，即int

   3.循环变量名称就是a,这个可以自己定义

IO之File类(输入输出流)

File对象主要用来获取文件本身的一些信息不涉及对文件的读写操作。

创建一个File对象的构造方法三个

File（String filename）;

File(String directoryPath,String filename);

File(Filef,String filename);

File类的下列方法获取文件本身的一些信息

PublicString getName（）//获取文件的名字

Publicboolean exits()//判断文件是否存在

Publiclong length（）//获取文件的长度，（单位是字节）

PublicString getAbsolutePath()//获取文件的绝对路径

File file=new File("C:\\Users\\Administrator\\Desktop\\test\\a.txt");

System.out.println(file.getAbsolutePath());

System.out.println(file.getName());

System.out.println(file.length());

File file2=newFile("C:\\Users\\Administrator\\Desktop\\test", "c.txt");

if(!file2.exists()){

try {

   file2.createNewFile();

   System.out.println("创建文件成功");

} catch (IOException e) {

   e.printStackTrace();

} 

}

1.  创建目录 public boolean mkdir()

2.  列出目录中的文件

Public String[]list()//用字符串的形式返回目录下的全部文件

PublicFile[] listFiles()//用File对象形式返回目录下的全部文件

常用：

Public String[] list(FilenameFilter obj)//用字符串的形式返回目录下的指定类型的所有文件

Public File[] listFile（FilenameFilterobj）//用File对象形式返回目录下的指定类型所有文件

FilenameFilterobj：过滤接口的对象

上述两方法的参数FilenameFilter是一个接口，该接口有一个方法

Public booleanaccept(File dir,String name)

File file2=new File("C:\\Users\\Administrator\\Desktop\\test");

FileAccept fileAccept=new FileAccept();

String[] fileNames=file2.list(fileAccept);

//增强for循环

for(String b:fileNames){

System.out.println(b);

}

Java.io提供了大量的流类，Java把inputstream抽象类的子类创建的流对象称作字节输入流。Outputstream抽象类的子类创建的流对象称作字节输出流。Java把read抽象类的子类创建的流对象称作字符输入流，write抽象类的子类创建的流对象称作字符输出流。（每一个字母为一个字节，一个汉字（字符）为两个字节）

因为应用程序要和文件打交道，所以提供了FileInputStream(文件字节输入流)和FileOuptStream（文件字节输出流）（Demo36）

FileInputStream类创建的对象被称为文件字节输入流

构造方法有

FileInputStream（String name）

FileInputStream(Filefile)(文件的路径或文件名)

FileInputStreamin =new FileInputStream(“hello.txt”)；

使用read方法以字节为单位读文件

Intread（）；

Intread（byte b[]）（字节数组）

Intread(byte b[],int off,int len);

文件字节输出流和文件字节输入流类似

它以字节为单位写文件，FileOutputStream流的目的地是文件，所以文件输出流调用write（byte b[]）方法把字节写入到文件

File file = new File("C:\\Users\\Administrator\\Desktop\\test\\a.txt");

      Filefile2 = newFile("C:\\Users\\Administrator\\Desktop\\test\\c.txt");

      byte[] b =new byte[100];

      Stringtxt="我是中国人";

      //将字符串转换为字节数组

      byte[] b2=txt.getBytes();

      try {

         FileInputStreamis = newFileInputStream(file);

         int len;

         try {

            while ((len = is.read(b)) !=-1) {

                // 将字节数组转换为字符串

                Stringstring = newString(b, 0, len);

                System.out.println(string);

            }

            is.close();

            //输出流

            FileOutputStreamos=newFileOutputStream(file2);

            os.write(b2);

            os.close();

         }catch(IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

         }

      }catch(FileNotFoundException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

}

文件字符输入输出流：（Demo37）

字节输入流和输出流的read和write方法使用字节数组读写数据，即以字节为基本单位处理数据。因此，字节不能很好的操作Unicode字符，例如一个汉字在文件中占用了2个字节，如果使用字节流，读取不当就可能会出现乱码

1. FileReader和FileWriter用来创建文件字符输入、输出流。

构造方法：

FileReader（String filename）

FileReader(Filefilename)

FileWriter(Stringfilename)

FileWriter(Filefilename)

2. 字符输入流和输出流的reader（）和writer（）方法以字符为基本单位处理数据（用字符数组）

 

   Filefile = newFile("C:\\Users\\Administrator\\Desktop\\test\\c.txt");

      Stringtxt = "hello 我是中国人";

//将字符串转化为字符数组

      char[] c = txt.toCharArray();

      try {

         FileWriterfw = newFileWriter(file);

         fw.write(c);

         fw.close();

         FileReaderfr = newFileReader(file);

         char[]c1 = newchar[100];

         int len;

         while ((len = fr.read(c1)) != -1) {

//将字符数组转化为字符串

            Stringstring = newString(c1, 0, len);

            System.out.println(string);

         }

         //注意：在while外关闭

         fr.close();

 

      }catch(IOException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

缓冲流：缓冲流增强了读写文件的能力，比如Student.txt是一个学生的名单，每个姓名占一行，如果我们想要读取名字，那么每次必须读取一行，使用FileReader流很难完成这样的任务，因为我们不清楚一行有多少字符，FileReader没有提供读取一行的方法。(Demo38)

1.BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。构造方法

BufferedRead（Reader in）reader的对象

BufferedWriter(writer out)

BufferedRead和BufferedWriter类读写文件的方法：

ReadLine() BufferedRead流读取文本行

Write（String s，int off，int len）BufferedWriter流把字符串s写到文件中

newline(); BufferedWriter流向文件写入一个换行符

      Filefile = newFile("C:\\Users\\Administrator\\Desktop\\test\\c.txt");

      String[]content = { "我是中国人","我爱祖国","中国很美丽" };

      try {

         FileWriterfw = newFileWriter(file);

         // 括号中应为filewriter的一个对象,所以要有上一句

         BufferedWriterbw = newBufferedWriter(fw);

         for (String str : content){

            bw.write(str);

            // 换行

            bw.newLine();

         }

         // 关闭时由外向内关，与打开时正好相反

         bw.close();

         fw.close();

         //读缓冲流

         FileReaderfr = newFileReader(file);

         BufferedReaderbr = newBufferedReader(fr);

         Stringstring = null;

         //一行一行进行读取

         while ((string =br.readLine()) !=null) {

            System.out.println(string);

         }

         br.close();

         fr.close();

      }catch(IOException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

泛型类：声明和创建对象时，类名后面多了一对“<>”,而且必须要用具体的类型替换<>中的泛型（Demo39）

泛型的 主要目的是可以建立具有类型安全的集合框架，如链表，散列映射等数据结构。

可以使用“class 名称<泛型列表>”声明一个类为了和普通的类有所区别，这样声明的类为泛型类。

Class ShowObject<E>

其中ShowObject是泛型类的名称，E是其中的泛型，也就是说我们并没有指定E是何种类型的数据，它可以是任何对象或接口，但不能是基本类型数据。

ShowObject类可以用泛型E作为自己的一个成员或方法中的参数，代码如下

Public class ShowObject<E>{

Public showMess(E b){

String mess=b.toString;//泛型变量只能调用tostring()方法，因为没有说明那个对象或接口，toString方法是由object类提供的

System.out.println(mess);

}

}

打开源码后按Ctrl+o可以看类所包含的方法

ArryList和LinkedList区别(Demo41)

LinkedList提供额外的get、remove、insert方法在linkedList的首部或尾部，这些操作使linkedlist可被用作堆栈（stack），队列（queue）或双向队列（deque）

ArrayList<Integer> arrayList =newArrayList<>();

      arrayList.add(1);

      arrayList.add(2);

      arrayList.add(3);

      for (int i = 0; i <arrayList.size(); i++) {

         System.out.println(arrayList.get(i));

      }

      LinkedList<String>linkedList = newLinkedList<>();

      linkedList.add("hello");

      linkedList.add("good");

      // 首部添加

      linkedList.addFirst("12");

      for (int i = 0; i <linkedList.size(); i++) {

         System.out.println(linkedList.get(i));

      }

   }

Set和Map

List 允许有相同的元素，set不保存重复的元素，因此存入set的每个元素都必须是唯一的，同时Set接口不保证维护元素的次序。（元素无次序）

它允许包含null的元素，但最多只能有一个null，因为不能重复。

它不能用下标的方法遍历（不能重复。。），使用迭代器（iterator）（又叫游标模式），再用while对迭代器进行遍历

   HashSet<String>hashSet=new HashSet<>();

   hashSet.add("2");

   hashSet.add("2");

   hashSet.add("3");

   hashSet.add("5");

   Iterator<String>iterator=hashSet.iterator();

   //判断下一个是否存在，hashNext()方法返回的是boolean类型

   while(iterator.hasNext()){

      //调用next方法的时候，向下移动指针，并且返回指针指向的元素

      Stringstring=iterator.next();

      System.out.println(string);

   }

迭代器原理

     

     1、当创建完成指向某个集合或者容器的Iterator对象是，这是的指针其实指向的是第一个元素的上方，即指向一个空

     2、当调用hasNext方法的时候，只是判断下一个元素的有无，并不移动指针

     3、当调用next方法的时候，向下移动指针，并且返回指针指向的元素，如果指针指向的内存中没有元素，会报异常。

     4、remove方法删除的元素是指针指向的元素。如果当前指针指向的内存中没有元素，那么会抛出异常。

Java为数据结构中的映射定义了一个接口Java.util.Map它有四个实现类，分别是HashmMap HashtableLinkedHashMap 和TreeMap

Map主要用于存储键值对，根据键得到值，因此不允许键重复，但允许值重复。

HashMap是一个最常用的Map,它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。

HashMap最多只允许一条记录的键为Null,允许多条记录的值为Null;

HashMap<String, String>hashMap=newHashMap<>();

   //将键和值放到hashmap中

   hashMap.put("name", "tom");

   hashMap.put("age", "11");

   //通过键获取值方法

   System.out.println(hashMap.get("age"));

   //hashMap.entrySet()获得一个set，然后又可以调用set中得迭代器（iterator）,然后可以进行遍历

   Iterator<Entry<String,String>> iterator=hashMap.entrySet().iterator();

   while(iterator.hasNext()){

      //Entry<String, String>对比hashset写

      Entry<String,String>entry=iterator.next();

System.out.println("key="+entry.getKey()+"val="+entry.getValue());