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流

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