Java入门学习笔记

Java常量

常量不同于常量值，它可以在程序中用符号来代替常量值使用，因此在使用前必须先定义。

1
2
3
4
5
final dataType(数据类型) variableName(变量名) = value(值)
//final        为定义常量的关键字
//dataType     指明常量的数据类型
//variableName 变量名称
//value        初始化的值
1
2
3
4
5
6
7
8
9
10
11
12
public class Hello{
    //用final修饰静态变量
    public static final double PI = 3.1415926;
    //用final修饰成员变量
    final int y = 10;
    
    public static void main(String args[])
    {
        //用final修饰局部变量
        final double x = 3.3;
    }
}

常量有三种类型：静态常量、成员常量、局部常量。

常量是不允许被修改的，比如用public static修饰的成员常量，在外部Hello.PI对其进行修改时候就会报错。

Java变量的作用域

  • 全局变量(实例变量) |无static修饰| |对象名.变量名| |生命周期：只要对象被当作引用，实例变量就将存在|
  • 静态变量(类变量) |static修饰| |类名.变量名| |生命周期：生命周期取决与类的生命周期。类被垃圾回收机构彻底回收才会被销毁|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class ClassDemo{
    //成员变量 | 实例变量
    String name;
    int age;
    
    //static修饰 成类变量类似C++中的 Hello::website ,Hello::URL
    static String website = "C语言中文网";
    static String URL     = "http://c.biancheng.net";
}

public class Hello{
    public static void main(String args[])
    {
        ClassDemo demo = new ClassDemo();
        System.out.println("无static修饰作用域：" + demo.name);
        System.out.println("  static修饰作用域：" + ClassDemo.website);
    }
}

Java数据类型

基本数据类型

基本数据类型关键字好像除了boolean其他都差不多，还有就是java中char占用两个字节，C/C++中默认占用一个字节。

类型名称 关键字 占用内存 取值范围
字节型 byte 1 字节 -128~127
短整型 short 2 字节 -32768~32767
整型 int 4 字节 -2147483648~2147483647
长整型 long 8 字节 -9223372036854775808L~9223372036854775807L
单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位）
双精度浮点型 double 8 字节 +/-1.8E+308 (15 个有效位）
字符型 char 2 字节 ISO 单一字符集
布尔型 boolean 1 字节 true 或 false

Java数据类型结构图

引用数据类型

引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。

引用数据类型是由用户自定义，用来限制其他数据的类型。另外，Java 语言中不支持 C++ 中的指针类型、结构类型、联合类型和枚举类型。

(害~ 没有指针感觉缺少了灵魂。)

引用类型还有一种特殊的 null 类型。所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。实际上，引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法。

(哦？？ 感觉打开了新大陆。)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class QuoteClass()
{
    static Cat lucky_quote;  //引用类型
    static Dog xiaohui_quote;//
}
class Cat()
{
    final String name = "lucky";
    int age = 3;
}
class Dog()
{
    final String name = "xiaohui";
    int age = 2;
}
public class Hello{
    public static void main(String[] args)
    {
            Cat lucky   = new Cat();    //创建了一个Cat类对象
            Dog xiaohui = new Dog();    //创建了一个Dog类对象
            //
            QuoteClass.lucky_quote   = lucky;
            QuoteClass.xiaohui_quote = xiaohui;
            //其中这里的QuoteClass.luck_quote 和 xiaohui_quote应该极速引用，其指向了lucky的内存
            System.out.println(lucky);
            System.out.println(xiaohui);
            System.out.println("---------------------------------------");
            System.out.println(QuoteClass.lucky_quote);
            System.out.println(QuoteClass.xiaohui_quote);
    }
}

运行结果：

1
2
3
4
5
com.cunyu1943.helloworld.Cat@48140564
com.cunyu1943.helloworld.Dog@58ceff1
---------------------------------------
com.cunyu1943.helloworld.Cat@48140564
com.cunyu1943.helloworld.Dog@58ceff1

String、StringBuffer、ArrayList、HashSet、HashMap这些都是引用类型。

1
2
3
4
5
6
7
8
9
10
11
String a = "123456";//a 指针指向了123456字面值的地址
String b = a;       //b 指向了a的地址,a的地址=123456字面值的地址
------------------------
String a = new String("123456");//a指向了堆地址
String b = a;      //同理
------------------------
String a = new String("hello"); //a指向了堆地址
String b = a;      //同理

a = "123456";//a重新指向了123456字面值的地址
//此时b指向的是属于栈中的"hello"

输出运行：

1
2
a = 123456
b = hello

两种数据类型比较

基本数据类型 引用数据类型
在栈中进行分配 在堆中进行分配,堆的读写速度远不及栈
变量名指向具体的数值 变量名指向存数据对象的内存地址,即变量名指向hash值
变量在声明之后java就会立刻分配给他内存空间 它以特殊的方式(类似C指针)指向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址
基本类型之间的赋值是创建新的拷贝 对象之间的赋值只是传递引用
“==” 和 “!=” 是在比较值 “==” 和 “!=” 是在比较两个引用地址是否相同，需要自己实现equals()方法
基本类型变量创建和销毁很快 类对象需要JVM去销毁（类似C++ new需要用户自己去释放）

Java运算符优先级

优先级 运算符 结合性
1 ()、[]、{} 从左向右
2 !、+、-、~、++、– 从右向左
3 *、/、% 从左向右
4 +、- 从左向右
5 «、»、>>> 从左向右
6 <、<=、>、>=、instanceof 从左向右
7 ==、!= 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= 从右向左

Java foreach语句用法

foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。

语法：

1
2
3
4
for(类型 变量名:集合)
{
    循环体;
}

例子：

1
2
3
4
5
6
7
8
9
10
11
int numbers[] = {1,2,3,4,5,6,7,8,9};
//foreach
for(int num:numbers)
{
    System.out.println(num);
}
String urls[] = {"http://www.baidu.com","http://www.bing.com.cn","http://www.freebuf.com"};
for(String url:urls)
{
    System.out.println(url);
}

输出：

1
2
3
4
1,2,3,4,5,6,7,8,9,
http://www.baidu.com
http://www.bing.com.cn
http://www.freebuf.com

Java字符串

Java 语言的文本数据被保存为字符或字符串类型。关于字符及字符串的操作主要用到 String 类和 StringBuffer 类，如连接、修改、替换、比较和查找等。

String定义

String()
String(String original)
String(char[ ]value)
String(char[] value,int offset,int count)

1
2
3
4
5
6
7
String strTemp = "hello";
String strNewTemp  = new String("helloNew");
String strNewTemp2 = new String(strTemp);
//char数组
char chArray[] = {'H','e','l','l','o'};
String strTempch0 = new String(chArray);//hello
String strTempch1 = new String(chArray,1,4);//ello

String转int

String 字符串转整型 int 有以下两种方式：

  • Integer.parseInt(str)
  • Integer.valueOf(str).intValue()

注意：Integer 是一个类，是 int 基本数据类型的封装类。

1
2
3
4
5
6
7
8
9
10
11
public class Hello{
    public static void main(String[] args)
    {
        String str = "123";
        int n = 0;
        System.out.println("第一种转换方法：Integer.parseInt(str)");
        n = Integer.parseInt(str);
        System.out.println("第二种转换方法：Integer.valueOf(str).intValue()")
        n = Integer.valueOf(str).intValue();
    }
}

int转String

整型 int 转 String 字符串类型有以下 3 种方法：

  • String s = String.valueOf(i);
  • String s = Integer.toString(i);
  • String s = “” + i;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Hello{
    public static void main(String[] args)
    {
        int n = 123;
        String str = new String();
        System.out.println("第一种转换方法：String.valueOf(i)");
        str = String.valueOf(n);
        System.out.println("第一种转换方法：Integer.toString(i)");
        str = Integer.toString(n);
        System.out.println("第一种转换方法：\"\"+i");
        str = ""+i;
        
    }
}

valueOf()方法是将数据的内部格式转换成可读的形式。属于一种静态方法，对于所有Java内置的类型，在字符串内被重载，以便每一种类型都能被转换成字符串。

parse()方法，parseXxxx这种形式，是指吧字符串转换成数值类型，其中Xxxx对应不同的数据类型，然后转换成Xxxx指定的类型，比如int和flat。

toString()方法，可以把一个引用类型强制转换为String字符串类型，是sun公司开发Java的时候为了方便所有类的字符串操作而特意加入的一个方法。

字符串拼接

1
2
3
4
5
6
7
//+拼接
"hello"+","+"World!"
//concat拼接
String str="";
str.concat("1");
str.concat("2");
str.concat("3");

获取字符串长度

1
2
String str = "123456";
str.length();

字符串大小写转换

1
2
3
4
5
String str = "aBcDEFg";
//转换小写
str.toLowerCase();
//转换大写
str.toUpperCase();

去除字符串中的空格

1
2
String str = "hello ,world"
str.trim();

substring截取字符串

1
2
String str = "hello,world!"
str.substring(0,5);//hello

splist分割字符串

1
2
3
String Colors  = "Red,Black,White,Yello,Blue";
String arrs[]  = Colors.splist(",");  //不限制个数
String arrs2[] = Colors.splist(",",3);//输出前三个

字符串比较

1
2
3
String str = "abc";
String str1 = "123";
System.out.println(str.equals(str2)); // 输出 false

equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。当比较两个字符串时，它会认为 A-Z 和 a-z 是一样的。

1
2
3
String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2));    // 输出 true

compareTo() 方法

通常，仅仅知道两个字符串是否相同是不够的。对于排序应用来说，必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串（String）的 compareTo() 方法实现了这种功能。

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    String str = "A";
    String str1 = "a";
    System.out.println("str=" + str);
    System.out.println("str1=" + str1);
    System.out.println("str.compareTo(str1)的结果是：" + str.compareTo(str1));
    System.out.println("str1.compareTo(str)的结果是：" + str1.compareTo(str));
    System.out.println("str1.compareTo('a')的结果是：" + str1.compareTo("a"));
}

输出:

1
2
3
4
5
str = A
str1 = a
str.compareTo(str1)的结果是：-32
str1.compareTo(str)的结果是：32
str1.compareTo('a')的结果是：0

StringBuffer类

因为 StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。

1
2
3
StringBuffer str1 = new StringBuffer();
StringBuffer str2 = new StringBuffer(10);      //10个字符容量的缓冲区
StringBuffer str3 = new StringBuffer("青春无悔");

追加字符串：对象.append(String str)

1
str1.append("Hello");

替换字符

1
str1.setCharAt(0,'h');

反转

1
str1.reverse();

删除

1
2
str1.deleteCharAt(1);
str1.delete(0,3);

String、StringBuffer和StringBuilder类的区别

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

  • String 类是不可变类，即一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
  • StringBuffer|StringBuilder = 字符串缓冲区
  • StringBuffer->线程安全 ,StringBuilder!=线程安全 性能更高

对CharSequence接口的实现

String 是 Java 中基础且重要的类，被声明为 final class，是不可变字符串。

Java类

类关键字

上述语法中各关键字的描述如下。

  • public：如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
  • abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
  • final：如果类被 final 修饰，则不允许被继承。
  • class：声明类的关键字。
  • class_name：类的名称。
  • 【extends】：表示继承其他类。
  • 【implements】：表示实现某些接口。
  • property_type：表示成员变量的类型。
  • property：表示成员变量名称。
  • function()：表示成员方法名称。

this指针

和C++差不多，类内隐藏的this指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 第一种定义Dog类方法
 **/
public class Dog {
    // 定义一个jump()方法
    public void jump() {
        System.out.println("正在执行jump方法");
    }
    // 定义一个run()方法，run()方法需要借助jump()方法
    public void run() {
        this.jump();
        //Dog d = new Dog();
        //d.jump();
        System.out.println("正在执行 run 方法");
    }
}

Java匿名对象

匿名对象就是没有明确的给出名字的对象，是对象的一种简写形式。

一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

1
2
3
4
5
6
7
8
9
10
public class Person()
{
    public void tell(){
        System.out.println("你好，我叫张三！");
    }
    public static void main(String args[])
    {
        new Person().tell();
    }
}

匿名对象在实际开发中基本都是作为其他类实例化对象的参数传递的

Java注释

类注释

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * @projectName（项目名称）: project_name
 * @package（包）: package_name.file_name
 * @className（类名称）: type_name
 * @description（类描述）: 一句话描述该类的功能
 * @author（创建人）: user 
 * @createDate（创建时间）: datetime  
 * @updateUser（修改人）: user 
 * @updateDate（修改时间）: datetime
 * @updateRemark（修改备注）: 说明本次修改内容
 * @version（版本）: v1.0
 */

方法注释

1
2
3
4
5
6
7
8
9
/**
 * @param num1: 加数1
 * @param num2: 加数2
 * @return: 两个加数的和
 */
public int add(int num1,int num2) {
    int value = num1 + num2;
    return value;
}

字段注释

1
2
3
4
5
6
/**
*定义用户名
*/
public String name;
/**定义密码*/
public String password;

修饰符访问

访问范围 private friendly(默认) protected public
同一个类 可访问 可访问 可访问 可访问
同一包中的其他类 不可访问 可访问 可访问 可访问
不同包中的子类 不可访问 不可访问 可访问 可访问
不同包中的非子类 不可访问 不可访问 不可访问 可访问

析构方法

Java中提供了protected类型的finalize()方法，任何Java类都可覆盖此方法，用此方法是否对象所有占用的相关资源操作。

对象的 finalize() 方法具有如下特点：

  • 垃圾回收器是否会执行该方法以及何时执行该方法，都是不确定的。
  • finalize() 方法有可能使用对象复活，使对象恢复到可触及状态。
  • 垃圾回收器在执行 finalize() 方法时，如果出现异常，垃圾回收器不会报告异常，程序继续正常运行。
1
2
3
4
protected void finalize()
{
    //对象清理工作.
}

Java包

Java包是类的集合，随着程序架构越来越大，类个数肯定也是越来越多，管理起来就特别不方便，所以为了解决这问题引入了(Package)包 机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理。

包的3个作用：

  • 区分相同名称的类。
  • 能够较好地管理大量的类。
  • 控制访问范围。

包定义

1
2
3
package 包名;
//例如
package com.demo.Helloworld;
  • 包名全部由小写字母（多个单词也全部小写）。
  • 包名一般由倒置的域名开头，比如com.baidu，不要有www。(www.freebuf.com.cn) cn.com.freebuf?
  • 自定义包不能java开头。

包导入

使用包中的其他类，用（包名+类名）

1
com.demo.Helloworld.Person zhansan = new com.demo.Helloworld.Person();

也可以用import语句

1
2
3
4
5
/**导入指定类*/
import 包名+类名;
import com.demo.Helloworld.Person
/**导入所有包下的类*/
import com.demo.Helloworld.*;

系统包

包 说明
java.lang Java 的核心类库，包含运行 Java 程序必不可少的系统类，如基本数据类型、基本数学函数、 字符串处理、异常处理和线程类等，系统默认加载这个包
java.io Java 语言的标准输入/输出类库，如基本输入/输出流、文件输入/输出、过滤输入/输出流等
java.util 包含如处理时间的 Date 类，处理动态数组的 Vector 类，以及 Stack 和 HashTable 类
java.awt 构建图形用户界面（GUI）的类库，低级绘图操作 Graphics 类、图形界面组件和布局管理 （如 Checkbox 类、Container 类、LayoutManger 接口等），以及用户界面交互控制和事 件响应（如 Event 类）
java.awt.image 处理和操纵来自网上的图片的 Java 工具类库
java.wat.peer 很少在程序中直接用到，使得同一个 Java 程序在不同的软硬件平台上运行
java.net 实现网络功能的类库有 Socket 类、ServerSocket 类
java.lang.reflect 提供用于反射对象的工具
java.util.zip 实现文件压缩功能
java.awt.datatransfer 处理数据传输的工具类，包括剪贴板、字符串发送器等
java.sql 实现 JDBC 的类库
java.rmi 提供远程连接与载入的支持
java. security 提供安全性方面的有关支持

Java多态、继承

Java抽象类

并且不是所有类都是用来描述对象的，当要给类中没有足够的信息描绘一个具体对象，那么这样的类称为抽象类。

1
2
3
<abstract>class <class_name>{
    <abstract> <type> <method_name> (参数列表)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class Shape{
    public int width; //几何图形长
    public int height;//几何图形宽
    
    /**构造方法*/
    public Shape(int width,int height)
    {
        this.width  = width;
        this.height = height;
    }
    
    public abstract double area();//抽象方法，计算面积
}

//抽象类集成 并实例化

1
2
3
4
5
6
7
8
9
10
11
12
public class Triangle extends Shape{//三角形类
    public Triangle(int width,int height)
    {
        super(width,height);//调用父类的
    }
    
    //这里必须重写！
    @Override
    public double area(){
        return 0.5 * width * height;
    }
}

Java接口

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的”抽象类”——接口（Interface）。接口是 Java 中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

interface接口定义

implements接口实现

接口定义

1
2
3
4
5
6
public interface interface_name extends other_interface_name {
    public interface_name(){...}//接口不允许构造方法
    String name;//接口变量必须初始化
    void getInfo();//等同于 public abstract void getInfo();
    public int sum();
}

接口实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test implements interface_name{
    private int number1;
    private int number2;
    public Test(int number1,int number2)
    {
        this.number1 = number1;
        this.number2 = number2;
    }
    //实现接口方法
    public int sum()
    {
        return number1+number2;
    }
    //实现接口方法
    public void getInfo()
    {
        System.out.println("infomation.");
    }
}

内部类

类A->定义类B，类B->定义类C，类C->定义类D。

类A是顶层类。

img

内部类特点：

  • 内部类(独立类)，编译后会生成.class文件，但是前面会有外部类$符号。
  • 内部类(可以自由访问外部类成员变量)
  • 内部类声明成静态，就不能随便访问外部类的成员变量，只能访问外部类静态成员变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test{
    //内部类
    public class InnerClass{
        public int getSum(int x,int y)
        {
            return x+y;
        }
    }///////////////////////
    
    public static void main(String args[])
    {
        Test.InnerClass ti = new Test().new InnerClass();
        
    }
}

匿名类

匿名类是值没有类名的内部类，必须在创建时使用new语句来声明类。

1
2
3
4
new 类|接口()
{
    //匿名类的主题
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Out {
    void show() {
        System.out.println("调用 Out 类的 show() 方法");
    }
}
public class TestAnonymousInterClass {
    // 在这个方法中构造一个匿名内部类
    private void show() {
        Out anonyInter = new Out() {
            // 获取匿名内部类的实例
            void show() {
                System.out.println("调用匿名类中的 show() 方法");
            }
        };
        anonyInter.show();
    }
    public static void main(String[] args) {
        TestAnonymousInterClass test = new TestAnonymousInterClass();
        test.show();
    }
}

Effectively final

1
2
3
4
5
6
7
8
9
10
11
public class Test {
    public static void main(String[] args) {
        String name = "C语言中文网";
        new Runnable() {
            @Override
            public void run() {
                System.out.println(name);
            }
        }
    }
}

Lambda表达式

1
2
3
4
5
//可计算接口
public interface Calculable{
    //计算两个int值  抽象函数
    int calculateInt(int a,int b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Test{
    /**
    *  通用操作符，进行计算
    * 
    * @param opr 操作符
    * @return 实现Calclable接口对象
    */
    public static Calculable calculate(char opr){
        Calulable result;
        if(opr == '+'){
            //匿名内部类实现Calculable接口
            result = new Calulable(){
                //实现加法运算
                @Override
                public int calculateInt(int a,int b){
                    return a+b;
                }
            };
        }else{
            result = new Calulable(){
                //实现减法运算
                @Override
                public int calculateInt(int a,int b){
                    return a-b;
                }
            };
        }
        return result;
    }
}

调用：

1
2
3
4
Calculable f1 = calculate('+');
Calculable f2 = calculate('-');
f1.calculateInt(1,2);
f2.calculateInt(2,1);

Lambda 表达式标准语法形式如下：

1
2
3
(参数列表) -> {
    // Lambda表达式体
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* 通过操作符，进行计算
* @param opr 操作符
* @return 实现Calculable接口对象
*/
public static Calculable calculate(char opr) {
    Calculable result;
    if (opr == '+') {
        // Lambda表达式实现Calculable接口
        result = (int a, int b) -> {
            return a + b;
        };
    } else {
        // Lambda表达式实现Calculable接口
        result = (int a, int b) -> {
            return a - b;
        };
    }
    return result;
}

Java集合、泛型

Java集合

集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量），而集合里只能保存对象（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。

Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口，这两个接口又包含了一些子接口或实现类。图 1 和图 2 分别为 Collection 和 Map 的子接口及其实现类。

Collection接口结构

Map接口结构

图 1 和图 2 中，黄色块为集合的接口，蓝色块为集合的实现类。表 1 介绍了这些接口的作用。

接口名称 作 用
Iterator 接口 集合的输出接口，主要用于遍历输出（即迭代访问）Collection 集合中的元素，Iterator 对象被称之为迭代器。迭代器接口是集合接口的父接口，实现类实现 Collection 时就必须实现 Iterator 接口。
Collection 接口 是 List、Set 和 Queue 的父接口，是存放一组单值的最大接口。所谓的单值是指集合中的每个元素都是一个对象。一般很少直接使用此接口直接操作。
Queue 接口 Queue 是 Java 提供的队列实现，有点类似于 List。
Dueue 接口 是 Queue 的一个子接口，为双向队列。
List 接口 是最常用的接口。是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。
Set 接口 不能包含重复的元素。
Map 接口 是存放一对值的最大接口，即接口中的每个元素都是一对，以 key➡value 的形式保存。

对于 Set、List、Queue 和 Map 这 4 种集合，Java 最常用的实现类分别是 HashSet、TreeSet、ArrayList、ArrayDueue、LinkedList 和 HashMap、TreeMap 等。表 2 介绍了集合中这些常用

类名称 作用
HashSet 为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单
TreeSet 实现了 Set 接口，是一个有序的 Set，这样就能从 Set 里面提取一个有序序列
ArrayList 一个用数组实现的 List，能进行快速的随机访问，效率高而且实现了可变大小的数组（类似C++ vector）
ArrayDueue 是一个基于数组实现的双端队列，按"先进先出"的方式操作集合元素
LinkedList 对顺序访问进行了优化，但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法，能把它当成栈（Stack）或队列（Queue）来用
HsahMap 按哈希算法来存取键对象
TreeMap 可以对键对象进行排序

HashMap

Map接口常用方法如下：

方法名称 说明
void clear() 删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key) 查询 Map 中是否包含指定的 key，如果包含则返回 true。
boolean containsValue(Object value) 查询 Map 中是否包含一个或多个 value，如果包含则返回 true。
V get(Object key) 返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value) 向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m) 将指定 Map 中的 key-value 对复制到本 Map 中。
V remove(Object key) 从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
boolean remove(Object key, Object value) 这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。
Set entrySet() 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
Set keySet() 返回 Map 集合中所有键对象的 Set 集合
boolean isEmpty() 查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。
int size() 返回该 Map 里 key-value 对的个数
Collection values() 返回该 Map 里所有 value 组成的 Collection 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Test{
    public static void main(String[] args)
    {
        //定义一个hashmap对象
        HashMap users = new HashMap();
        users.put("11","张三");//往hashmap里面放key-value
        users.put("22","李四");
        users.put("33","王五");
        users.put("44","赵六");
        //遍历
        Iterator it = users.keySet().iterator();
        while(it.hashNext()){
            Object key   = it.next();
            Object value = users.get(key);
            System.out.println("id:"+key+","+"name:"+value);
        }
        //for循环遍历
        for(Map.Entry<String,String> entry:users.entrySet())
        {
            String mapKey   = entry.getKey();
            String mapValue = entry.getValue();
        }
        //for-each遍历
        for(String key:users.keySet())
        {
            System.out.println(key);
        }
        for(String value:users.values())
        {
            System.out.println(value)
        }
    }
}

泛型

这里偷懒，就类似C++里面的那种 vector<int,int> 这里面<>就是泛型 ，然后java里面可以写(T,K) 这里面的T,K 形参可以代表泛型

Java反射机制

反射机制很厉害，他属于是运行时，利用反射机制获取到class或对象的值，然后就能拿到类 对象的所有属性，hook中很常用这种机制，xposed hook机制了解后再详细的来看。

Java IO流

应该和其他语言差不多，暂时先不写了。