Java入门学习笔记
Java入门学习笔记
Java常量
常量不同于常量值,它可以在程序中用符号来代替常量值使用,因此在使用前必须先定义。
final dataType(数据类型) variableName(变量名) = value(值)
//final 为定义常量的关键字
//dataType 指明常量的数据类型
//variableName 变量名称
//value 初始化的值
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修饰| |类名.变量名| |生命周期:生命周期取决与类的生命周期。类被垃圾回收机构彻底回收才会被销毁|
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 语言中不支持 C++ 中的指针类型、结构类型、联合类型和枚举类型。
(害~ 没有指针感觉缺少了灵魂。)
引用类型还有一种特殊的 null
类型。所谓引用数据类型就是对一个对象的引用
,对象包括实例和数组两种。实际上,引用类型变量
就是一个指针
,只是 Java 语言里不再使用指针这个说法。
(哦?? 感觉打开了新大陆。)
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);
}
}
运行结果:
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
这些都是引用类型。
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"
输出运行:
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 为开发者提供了极大的方便。
语法:
for(类型 变量名:集合)
{
循环体;
}
例子:
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,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)
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 基本数据类型的封装类。
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;
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的时候为了方便所有类的字符串操作而特意加入的一个方法。
字符串拼接
//+拼接
"hello"+","+"World!"
//concat拼接
String str="";
str.concat("1");
str.concat("2");
str.concat("3");
获取字符串长度
String str = "123456";
str.length();
字符串大小写转换
String str = "aBcDEFg";
//转换小写
str.toLowerCase();
//转换大写
str.toUpperCase();
去除字符串中的空格
String str = "hello ,world"
str.trim();
substring截取字符串
String str = "hello,world!"
str.substring(0,5);//hello
splist分割字符串
String Colors = "Red,Black,White,Yello,Blue";
String arrs[] = Colors.splist(","); //不限制个数
String arrs2[] = Colors.splist(",",3);//输出前三个
字符串比较
String str = "abc";
String str1 = "123";
System.out.println(str.equals(str2)); // 输出 false
equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同,唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。当比较两个字符串时,它会认为 A-Z 和 a-z 是一样的。
String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2)); // 输出 true
compareTo() 方法
通常,仅仅知道两个字符串是否相同是不够的。对于排序应用来说,必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串(String)的 compareTo() 方法实现了这种功能。
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"));
}
输出:
str = A
str1 = a
str.compareTo(str1)的结果是:-32
str1.compareTo(str)的结果是:32
str1.compareTo('a')的结果是:0
StringBuffer类
因为 StringBuffer 类是可变字符串类
,创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串,如果字符串的长度超过了 StringBuffer 类对象的容量,则该对象的容量会自动扩大。
StringBuffer str1 = new StringBuffer();
StringBuffer str2 = new StringBuffer(10); //10个字符容量的缓冲区
StringBuffer str3 = new StringBuffer("青春无悔");
追加字符串:对象.append(String str)
str1.append("Hello");
替换字符
str1.setCharAt(0,'h');
反转
str1.reverse();
删除
str1.deleteCharAt(1);
str1.delete(0,3);
String、StringBuffer和StringBuilder类的区别
在 Java 中字符串属于对象
,Java 提供了 String 类来创建和操作字符串。
- String 类是
不可变类
,即一旦一个 String 对象被创建以后,包含在这个对象中的字符序列是不可改变的
,直至这个对象被销毁。 - StringBuffer|StringBuilder = 字符串缓冲区
- StringBuffer->线程安全 ,StringBuilder!=线程安全 性能更高
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指针
/**
* 第一种定义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匿名对象
匿名对象就是没有明确的给出名字的对象,是对象的一种简写形式。
一般匿名对象只使用一次,而且匿名对象只在堆内存
中开辟空间,而不存在栈内存的引用。
public class Person()
{
public void tell(){
System.out.println("你好,我叫张三!");
}
public static void main(String args[])
{
new Person().tell();
}
}
匿名对象在实际开发中基本都是作为其他类实例化对象
的参数
传递的
Java注释
类注释
/**
* @projectName(项目名称): project_name
* @package(包): package_name.file_name
* @className(类名称): type_name
* @description(类描述): 一句话描述该类的功能
* @author(创建人): user
* @createDate(创建时间): datetime
* @updateUser(修改人): user
* @updateDate(修改时间): datetime
* @updateRemark(修改备注): 说明本次修改内容
* @version(版本): v1.0
*/
方法注释
/**
* @param num1: 加数1
* @param num2: 加数2
* @return: 两个加数的和
*/
public int add(int num1,int num2) {
int value = num1 + num2;
return value;
}
字段注释
/**
*定义用户名
*/
public String name;
/**定义密码*/
public String password;
修饰符访问
访问范围 | private | friendly(默认) | protected | public |
---|---|---|---|---|
同一个类 | 可访问 | 可访问 | 可访问 | 可访问 |
同一包中的其他类 | 不可访问 | 可访问 | 可访问 | 可访问 |
不同包中的子类 | 不可访问 | 不可访问 | 可访问 | 可访问 |
不同包中的非子类 | 不可访问 | 不可访问 | 不可访问 | 可访问 |
析构方法
Java中提供了protected
类型的finalize()
方法,任何Java类都可覆盖此方法,用此方法是否对象所有占用的相关资源操作。
对象的 finalize() 方法具有如下特点:
- 垃圾回收器是否会执行该方法以及何时执行该方法,都是不确定的。
- finalize() 方法有可能使用对象复活,使对象恢复到可触及状态。
- 垃圾回收器在执行 finalize() 方法时,如果出现异常,垃圾回收器不会报告异常,程序继续正常运行。
protected void finalize()
{
//对象清理工作.
}
Java包
Java包是类的集合,随着程序架构越来越大,类个数肯定也是越来越多,管理起来就特别不方便,所以为了解决这问题引入了(Package)包 机制,提供了类的多层命名空间,用于解决类的命名冲突、类文件管理。
包的3个作用:
- 区分相同名称的类。
- 能够较好地管理大量的类。
- 控制访问范围。
包定义
package 包名;
//例如
package com.demo.Helloworld;
- 包名全部由小写字母(多个单词也全部小写)。
- 包名一般由倒置的域名开头,比如com.baidu,不要有www。(www.freebuf.com.cn) cn.com.freebuf?
- 自定义包不能
java
开头。
包导入
使用包中的其他类,用(包名+类名)
com.demo.Helloworld.Person zhansan = new com.demo.Helloworld.Person();
也可以用import语句
/**导入指定类*/
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抽象类
并且不是所有类都是用来描述对象的,当要给类中没有足够的信息描绘一个具体对象,那么这样的类称为抽象类。
<abstract>class <class_name>{
<abstract> <type> <method_name> (参数列表)
}
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();//抽象方法,计算面积
}
//抽象类集成 并实例化
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
接口实现
接口定义
public interface interface_name extends other_interface_name {
public interface_name(){...}//接口不允许构造方法
String name;//接口变量必须初始化
void getInfo();//等同于 public abstract void getInfo();
public int sum();
}
接口实现
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是顶层类。
内部类特点:
- 内部类(独立类),编译后会生成.class文件,但是前面会有
外部类$
符号。 - 内部类(可以自由访问外部类成员变量)
- 内部类声明成静态,就不能随便访问外部类的成员变量,只能访问外部类静态成员变量。
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语句来声明类。
new 类|接口()
{
//匿名类的主题
}
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
public class Test {
public static void main(String[] args) {
String name = "C语言中文网";
new Runnable() {
@Override
public void run() {
System.out.println(name);
}
}
}
}
Lambda表达式
//可计算接口
public interface Calculable{
//计算两个int值 抽象函数
int calculateInt(int a,int b);
}
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;
}
}
调用:
Calculable f1 = calculate('+');
Calculable f2 = calculate('-');
f1.calculateInt(1,2);
f2.calculateInt(2,1);
Lambda 表达式标准语法形式如下:
(参数列表) -> {
// Lambda表达式体
}
/**
* 通过操作符,进行计算
* @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 的子接口及其实现类。
图 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 |
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流
应该和其他语言差不多,暂时先不写了。
本文来自博客园,作者:VxerLee,转载请注明原文链接:https://www.cnblogs.com/VxerLee/p/15555004.html 专注逆向、网络安全 ——VxerLee