Java基础知识总结

最新推荐文章于 2021-06-18 22:08:37 发布

Aoing97

最新推荐文章于 2021-06-18 22:08:37 发布

阅读量1.2k

点赞数

分类专栏： Java笔记

本文链接：https://blog.csdn.net/qq_39120849/article/details/104110634

版权

Java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java基础知识总结

原笔记网址

1、数组

1.1 Arrays.split(“”) 方法输入参数是正则串

split方法的输入参数理应是个正则串，并非普通的分隔字符。由于点号和竖线都是正则串的保留字符，因此无法直接在正则串中填写，必须进行转义处理方可。正则字符串通过在原字符前面添加两个反斜杆来转义，像点号字符在正则串中对应的转义符为“.”，而竖线在正则串中对应的转义符为“|”。

// 通过点号分割字符串
private static void splitByDot() {    
	String dotStr = "123.456.789";    
	// split(".")无法得到分割后的字符串数组    
	//String[] dotArray = dotStr.split(".");    
	// 点号是正则串的保留字符，需要进行转义（在点号前面加两个反斜杆）
	String[] dotArray = dotStr.split("\\.");    
	for (String item : dotArray) { 
		System.out.println("dot item = "+item);    
	}
}

// 通过竖线分割字符串
private static void splitByLine() {    
	String lineStr = "123|456|789";    
	// split("|")分割得到的字符串数组，每个数组元素只有一个字符，类似于toCharArray的结果    
	//String[] lineArray = lineStr.split("|");    
	// 竖线是正则串的保留字符，需要进行转义（在竖线前面加两个反斜杆）    
	String[] lineArray = lineStr.split("\\|");    
	for (String item : lineArray) {       
		System.out.println("line item = "+item);    
	}
}

2、正则表达式的保留字符

保留字符	说明
()	把圆括号内外的表达式区别开来。
[]	表示方括号内部的字符互相之间是或的关系。
{}	花括号中间填写数字，表示花括号前面的字符有多少位。
\|	对前面和后面的字符进行或运算，表示既可以是前面的字符，也可以是后面的字符。
-	与前面和后面的字符组合起来，代表两个字符之间的所有连续字符。
.	代表除了回车符和换行符以外的其它字符。
+	表示加号前面的字符可以有一位，也可以有多位。
*	表示星号前面的字符可以有一位，也可以有多位，还可以没有（0位）。
\	两个反斜杆可对保留字符进行转义，表示保留字符的自身符号。

3、多态的理解

公鸡Cock 和母鸡Hen都继承自Chicken

//演示类的多态性
public class TestChicken {    
	public static void main(String[] args) {        
		// 鸡类的实例变成了一只公鸡        
		Chicken chicken = new Cock();        
		// 此时鸡类的叫声就变为公鸡的叫声        
		chicken.call();        
		// 鸡类的实例变成了一只母鸡       
		chicken = new Hen();        
		// 此时鸡类的叫声就变为母鸡的叫声        
		chicken.call();    
	}
}

//喔喔喔咯咯咯

引入多态概念的好处是:
只要某些类型都从同一个父类派生而来，就能在方法内部把它们当作同一种类型来处理，而无需区分具体的类型。仍以鸡叫为例，不管是公鸡叫还是母鸡叫，都是某种鸡在叫，于是完全可以定义一个叫唤方法，根据输入的鸡参数，让这只鸡自己去叫即可。叫唤方法的具体代码如下所示：

// 定义一个叫唤方法，传入什么鸡，就让什么鸡叫 
private static void call(Chicken chicken) { 
    chicken.call(); 
}

这下有了通用的鸡叫方法，外部就能把鸡类的实例作为输入参数填进去。当输入参数为公鸡实例的时候，call方法上演的是公鸡喔喔叫；当输入参数为母鸡实例的时候，call方法上演的是母鸡咯咯叫。

call(new Cock()); // 公鸡叫 
call(new Hen()); // 母鸡叫

4、对象的类型检查

“A instanceof B”，意思是检查A实例是否属于B类型

// 利用关键字instanceof检查某实例的归属类
private static void checkInstance(Chicken chicken) {
    if (chicken instanceof Cock) { // 判断这只鸡是不是公鸡
        System.out.println("检查对象实例：这是只公鸡。");
    } else if (chicken instanceof Hen) { // 判断这只鸡是不是母鸡
        System.out.println("检查对象实例：这是只母鸡。");
    } else {
        System.out.println("检查对象实例：这既不是公鸡也不是母鸡。");
    }
}

5、final修饰

一旦某个类被final修饰，则该类无法再派生出任何子类。	
一旦某个成员属性被final修饰，则该属性不能再次赋值了。
一旦某个成员方法被final修饰，则该方法禁止被子类重载。

6、内部类的创建实例

内部类：

//演示内部类的简单定义
public class Tree {
    private String tree_name;
    
    public Tree(String tree_name) {
        this.tree_name = tree_name;
    }
    public void sprout() {
        System.out.println(tree_name+"发芽啦");
        // 外部类访问它的内部类，就像访问其它类一样，都要先创建类的实例，再访问它的成员
        Flower flower = new Flower("花朵");
        flower.bloom();
    }
    
    // Flower类位于Tree类的内部，它是个内部类
    public class Flower {
        private String flower_name;
        public Flower(String flower_name) {
            this.flower_name = flower_name;
        }
        public void bloom() {
            System.out.println(flower_name+"开花啦");
        }
    }
}

直接通过new关键字是无法创建内部类实例的。只有先创建外部类的实例，才能基于该实例去new内部类的实例，内部实例的创建代码格式形如“外部类的实例名.new 内部类的名称(…)”

// 先创建外部类的实例，再基于该实例去创建内部类的实例
TreeInner inner = new TreeInner("桃树");
// 创建一个内部类的实例，需要在new之前添加“外层类的实例名.”
TreeInner.Flower flower = inner.new Flower("桃花");
flower.bloom(); // 调用内部类实例的bloom方法

当内部类与外部类有重名属性时：

// 该方法访问内部类自身的tree_name字段
public void bloomInnerTree() {
    // 内部类里面的this关键字指代内部类自身
    System.out.println(this.tree_name+"的"+flower_name+"开花啦");
}


// 该方法访问外部类TreeInner的tree_name字段
public void bloomOuterTree() {
    // 要想在内部类里面访问外部类的成员，就必须在this之前添加“外部类的名称.”
    System.out.println(TreeInner.this.tree_name+"的"+flower_name+"开花啦");
}

内部静态类：

//演示嵌套类的定义
public class TreeNest {
    private String tree_name;
    public TreeNest(String tree_name) {
        this.tree_name = tree_name;
    }
    public void sprout() {
        System.out.println(tree_name+"发芽啦");
    }
    
    // Flower类虽然位于TreeNest类的里面，但是它被static修饰，故而与TreeNest类的关系比起一般的内部类要弱。
    // 为了与一般的内部类区别开来，这里的Flower类被叫做嵌套类。
    public static class Flower {
        private String flower_name;
        
        public Flower(String flower_name) {
            this.flower_name = flower_name;
        }
        public void bloom() {
            System.out.println(flower_name+"开花啦");
        }
        public void bloomOuterTree() {
            // 注意下面的写法是错误的，嵌套类不能直接访问外层类的成员
            //System.out.println(TreeNest.this.tree_name+"的"+flower_name+"开花啦");
        }
    }
}

// 演示嵌套类的调用方法
private static void testNest() {
    // 创建一个嵌套类的实例，格式为“new 外层类的名称.嵌套类的名称(...)”
    TreeNest.Flower flower = new TreeNest.Flower("桃花");
    flower.bloom();
}

7、static修饰

7.1 静态代码块

静态代码块作用是在系统加载该类之时立即执行这部分代码，静态代码块与构造方法比起来，它们的执行顺序？
静态代码块先于构造方法

// 叶子数量，用来演示构造方法与初始静态代码块的执行顺序
public static int leaf_count = 0;

// static还能用来包裹某个代码块，一旦当前类加载进内存，静态代码块就立即执行
static {
	leaf_count++;
	System.out.println("这里是初始的静态代码块，此时叶子数量为"+leaf_count);
}

public TreeStatic(String tree_name) {
	this.tree_name = tree_name;
	leaf_count++;
	System.out.println("这里是构造方法，此时叶子数量为"+leaf_count);
}

// 演示静态代码块与构造方法的执行顺序
private static void testStaticBlock() {
	System.out.println("开始创建树木类的实例");
	TreeStatic tree = new TreeStatic("月桂");
	System.out.println("结束创建树木类的实例");
}

这里是初始的静态代码块，此时叶子数量为1
开始创建树木类的实例
这里是构造方法，此时叶子数量为2
结束创建树木类的实例

7.2 静态属性的持久性

凡是被static修饰的静态变量，它在内存中占据了一块固定的区域，不管所在类被创建了多少个实例，每个实例引用的静态变量依然是最初分配的那个。

// 树木年轮，用来演示静态属性的持久性
public static int annual_ring = 0;

// 注意每次读取静态属性，得到的都是该属性最近一次的数值
public void grow() {
	annual_ring++;
	System.out.println(tree_name+"的树龄为"+annual_ring);
}

// 演示静态属性的持久性
private static void testStaticProperty() {
	TreeStatic bigTree = new TreeStatic("大树");
	bigTree.grow();
	TreeStatic littleTree = new TreeStatic("小树");
	littleTree.grow();
}

这里是构造方法，此时叶子数量为3
大树的树龄为1
这里是构造方法，此时叶子数量为4
小树的树龄为2

8、枚举

枚举类型提供的通用方法主要有两个，其中ordinal方法可获得该枚举的序号，toString可获得该枚举的字段名称

// 演示简单枚举类型的调用方式
private static void testEnum() {
	Season spring = Season.SPRING; // 声明一个春天的季节实例
	Season summer = Season.SUMMER; // 声明一个夏天的季节实例
	Season autumn = Season.AUTUMN; // 声明一个秋天的季节实例
	Season winter = Season.WINTER; // 声明一个冬天的季节实例
	// 枚举类型提供的通用方法主要有两个，
	// 其中ordinal方法可获得该枚举的序号，toString可获得该枚举的字段名称
	System.out.println("spring number="+spring.ordinal()+", name="+spring.toString());
	System.out.println("summer number="+summer.ordinal()+", name="+summer.toString());
	System.out.println("autumn number="+autumn.ordinal()+", name="+autumn.toString());
	System.out.println("winter number="+winter.ordinal()+", name="+winter.toString());
}

spring number=0, name=SPRING
summer number=1, name=SUMMER
autumn number=2, name=AUTUMN
winter number=3, name=WINTER

自定义枚举

//演示枚举类型的扩展定义
public enum SeasonCn {
	// 在定义枚举变量的同时，调用该枚举变量的构造方法
	SPRING(1,"春天"), SUMMER(2,"夏天"), AUTUMN(3,"秋天"), WINTER(4,"冬天");

	private int value; // 定义季节的阿拉伯数字
	private String name; // 定义季节的中文名称字段

	// 在构造方法中传入该季节的阿拉伯数字和中文名称
	private SeasonCn(int value, String name) {
		this.value = value;
		this.name = name;
	}

	// 获取季节的阿拉伯数字
	public int getValue() {
		return this.value;
	}

	// 获取季节的中文名称
	public String getName() {
		return this.name;
	}
}

需将原来的ordinal方法替换为getValue方法，将原来的toString方法替换为getName方法。

// 演示扩展枚举类型的调用方式
private static void testEnumCn() {
	SeasonCn spring = SeasonCn.SPRING; // 声明一个春天的季节实例
	SeasonCn summer = SeasonCn.SUMMER; // 声明一个夏天的季节实例
	SeasonCn autumn = SeasonCn.AUTUMN; // 声明一个秋天的季节实例
	SeasonCn winter = SeasonCn.WINTER; // 声明一个冬天的季节实例
	// 通过扩展而来的getName方法，可获得该枚举预先设定的中文名称
	System.out.println("spring number="+spring.getValue()+", name="+spring.getName());
	System.out.println("summer number="+summer.getValue()+", name="+summer.getName());
	System.out.println("autumn number="+autumn.getValue()+", name="+autumn.getName());
	System.out.println("winter number="+winter.getValue()+", name="+winter.getName());
}

spring number=1, name=春天
summer number=2, name=夏天
autumn number=3, name=秋天
winter number=4, name=冬天

9、接口

9.1接口的成员变量

（java8以前）
接口内部的属性，则默认为终态属性，即添加了final前缀的成员属性。

（java8及以后）
1、增加了默认方法，并通过前缀default来标识。接口内部需要编写默认方法的完整实现代码，这样实现类无需重写该方法即可直接继承并使用，仿佛默认方法就是父类方法一样，唯一的区别在于实现类不允许重写默认方法。
2、增加了静态属性和静态方法，而且都通过前缀static来标识。接口的静态属性同时也是终态属性，初始化赋值之后便无法再次修改；接口的静态方法不能被实现类继承，因而实现类允许定义同名的静态方法，缘于接口的静态方法与实现类的静态方法没有任何关联，仅仅是它俩恰好同名而已。

//定义一个增加了Java8新特性的接口
public interface ExpandBehavior {

	// 声明了一个抽象的飞翔方法
	public void fly();

	// 声明了一个抽象的游泳方法
	public void swim();

	// 声明了一个抽象的奔跑方法
	public void run();
	
	// 默认方法，以前缀default标识。默认方法不支持重写，但可以被继承。
	public default String getOrigin(String place, String name, String ancestor) {
		return String.format("%s%s的祖先是%s。", place, name, ancestor);
	}

	public static int MALE = 0;
	public static int FEMALE = 1;
	// 接口内部的静态属性也默认为终态属性，所以final前缀可加可不加
	//public final static int MALE = 0;
	//public final static int FEMALE = 1;
	// 静态方法，以关键字static标识。静态方法支持重写，但不能被继承。
	public static String getNameByLeg(int leg_count) {
		if (leg_count == 2) {
			return "二足动物";
		} else if (leg_count == 4) {
			return "四足动物";
		} else if (leg_count >= 6) {
			return "多足动物";
		} else {
			return "奇异动物";
		}
	}
}

根据上面的扩展接口，重新编写实现了该接口的鹅类，其中fly、swim、run这三个抽象方法均须重写，唯有默认方法getOrigin不要重写，并且鹅类代码当中可以直接调用这个默认方法。新写的鹅类代码ExpandGoose示例如下：

//定义实现了扩展接口的鹅类
public class ExpandGoose extends Bird implements ExpandBehavior {

	public ExpandGoose(String name, int sexType) {
		super(name, sexType);
	}

	// 实现了接口的fly方法
	@Override
	public void fly() {
		System.out.println("鹅飞不高，也飞不远。");
	}

	// 实现了接口的swim方法
	@Override
	public void swim() {
		System.out.println("鹅，鹅，鹅，曲项向天歌。白毛浮绿水，红掌拨清波。");
	}

	// 实现了接口的run方法
	@Override
	public void run() {
		System.out.println("槛外萧声轻荡漾，沙间鹅步满蹒跚。");
	}
	
	// 根据产地和祖先拼接并打印该动物的描述文字
	public void show(String place, String ancestor) {
		// getOrigin是来自扩展接口ExpandBehavior的默认方法，可以在实现类中直接使用
		String desc = getOrigin(place, getName(), ancestor);
		System.out.println(desc);
	}
}

接着轮到外部访问这个鹅类ExpandGoose了，表面上外部仍跟平常一样调用鹅类的成员方法，然而在调用接口的静态成员时有所差别。对于接口的静态属性，外部依然能够通过鹅类直接访问，访问格式形如“实现类的名称.静态属性名”；对于接口的静态方法，外部却不能通过鹅类访问了，因为实现类并未继承接口的静态方法，所以外部只能通过接口自身访问它的静态方法，访问格式形如“扩展接口的名称.静态方法名(***)”。下面是外部调用鹅类ExpandGoose的代码例子：

// 演示扩展接口的实现类用法
private static void testExpand() {
	// 实现类可以继承接口的静态属性
	ExpandGoose goose = new ExpandGoose("鹅", ExpandGoose.FEMALE);
	goose.show("中国", "鸿雁");
	goose.show("欧洲", "灰雁");
	// 接口中的静态方法没有被实现类所继承，因而只能通过扩展接口自身访问
	String typeName = ExpandBehavior.getNameByLeg(2);
	System.out.println("鹅是"+typeName);
}

中国鹅的祖先是鸿雁。
欧洲鹅的祖先是灰雁。
鹅是二足动物

10、集合

10.1 Set集合

集合分成哈希集合（HashSet）与二叉集合(TreeSet)两类。

哈希集合里面保存的各元素是无序的，因为一个数据的哈希结果是散列值。
由于二叉集合内部采取二叉树存储数据，每次新增元素的操作都会进行大小比较，最终得到的二叉集合必定是有序的。

如果是开发者自己定义的数据类型（新的类），就要求开发者自己来实现计算方法和比较方法。譬如有个自定义的手机类MobilePhone，该类的定义代码见下：

//定义一个手机类
public class MobilePhone {
	private String brand; // 手机品牌
	private Integer price; // 手机价格

	public MobilePhone(String brand, int price) {
		this.brand = brand;
		this.price = price;
	}

	// 获取手机品牌
	public String getBrand() {
		return this.brand;
	}

	// 获取手机价格
	public int getPrice() {
		return this.price;
	}
}

就哈希集合的哈希值计算而言，自定义的手机类需要重写hashCode和equals方法，其中hashCode方法计算得到的哈希值对应于该对象的保存位置，而equals方法用来判断该位置上的几个元素是否完全相等。一方面，我们要保证品牌与价格都相同的两个元素，它们的哈希值必须也相等；另一方面，即使两个元素的品牌和价格不一致，它们的哈希值也可能恰巧相等，于是还需要equals方法进一步校验是否存在重复。按照上述要求，重写后的hashCode和equals方法代码示例如下：

// hashCode方法计算出来的哈希值对应于该对象的保存位置
@Override
public int hashCode() {
	return brand.hashCode() + price.hashCode();
}

// 同一个存储位置上可能有多个对象（哈希值恰好相等），
// 此时系统自动调用equals方法判断是否存在相同的对象。
@Override
public boolean equals(Object obj) {
	if (!(obj instanceof MobilePhoneHash)) {
		return false;
	}
	MobilePhoneHash other = (MobilePhoneHash) obj;
	// 手机品牌和手机价格都相等，才算是这两个手机相等
	boolean equals = this.brand.equals(other.brand) && this.price.equals(other.price);
	return equals;
}

至于二叉集合的节点大小比较，则需手机类实现接口Comparable，并具体定义该接口声明的compareTo方法（该方法用来比较两个元素的大小关系）。其实这里的Comparable接口与数组排序用到的Comparator接口作用类似，都是判断两个对象谁大谁小。如果要求二叉集合里面的手机元素按照价格排序，则compareTo方法主要校验当前手机的价格与其它手机的价格。详细的接口实现代码如下所示：

public class MobilePhoneTree implements Comparable<MobilePhoneTree> {
	// 此处省略手机类的构造方法、成员属性与成员方法定义

	// 二叉树除了检查是否相等，还要判断先后顺序。
	// 相等和先后顺序的校验结果从compareTo方法获得。
	@Override
	public int compareTo(MobilePhoneTree other) {
		if (this.price.compareTo(other.price) > 0) { // 当前价格较高
			return 1;
		} else if (this.price.compareTo(other.price) < 0) { // 当前价格较低
			return -1;
		} else {
			return this.brand.compareTo(other.brand);
		}
	}
}

结果应当为：哈希集合不会插入重复的手机对象，并且二叉集合里的各手机元素按照价格升序排列。

10.2 Map集合

遍历映射内部的所有元素

1、通过迭代器遍历
首先调用映射实例的 entrySet 获得该映射的集合入口，再调用入口对象的iterator方法获得映射的迭代器，然后使用迭代器遍历整个映射。

// 第一种遍历方式：显式指针，即使用迭代器
Set<Map.Entry<String, MobilePhone>> entry_set = map.entrySet();
Iterator<Map.Entry<String, MobilePhone>> iterator = entry_set.iterator();
while (iterator.hasNext()) {
	// 注意这里要先把入口取出来，这样才能分别getKey和getValue
	Map.Entry<String, MobilePhone> iterator_item = iterator.next();
	// 获取该键值对的键名
	String key = iterator_item.getKey();
	// 获取该键值对的键值
	MobilePhone value = iterator_item.getValue();
	System.out.println(String.format("iterator_item key=%s, value=%s %d", 
			key, value.getBrand(), value.getPrice()));
}

2、通过for循环遍历

// 第二种遍历方式：隐式指针，即使用for循环
for (Map.Entry<String, MobilePhone> for_item : map.entrySet()) {
	// 获取该键值对的键名
	String key = for_item.getKey();
	// 获取该键值对的键值
	MobilePhone value = for_item.getValue();
	System.out.println(String.format("for_item key=%s, value=%s %d", 
			key, value.getBrand(), value.getPrice()));
}

3、通过键名集合遍历

// 第三种遍历方式：先获得键名的集合，再通过键名集合遍历整个映射
// 注意：HashMap的keySet方法返回的是无序集合
Set<String> key_set = map.keySet();
for (String key : key_set) {
	// 通过键名获取该键值对的键值
	MobilePhone value = map.get(key);
	System.out.println(String.format("set_item key=%s, value=%s %d", 
			key, value.getBrand(), value.getPrice()));
}

4、通过forEach方法遍历

// 第四种遍历方式：使用forEach方法夹带Lambda表达式进行遍历
map.forEach((key, value) -> 
		System.out.println(String.format("each_item key=%s, value=%s %d", 
				key, value.getBrand(), value.getPrice())) );

11、泛型

问号<?>跟泛型比较的话，主要有以下几点区别：

问号只能用于给泛型类创建实例，本身不能创建实例。而泛型T既可用于泛型类创建实例，也可用于给自身创建实例，如“T t;”
问号只可用作输入参数，不可用作输出参数。而泛型T用于二者皆可。
使用了问号的容器实例，只允许调用get方法，不允许调用add方法。而泛型容器不存在方法调用的限制。

11.1 Java8新增的几种泛型接口

11.1.1 断言接口Predicate

先定义一个苹果类Apple

//定义一个苹果类
public class Apple {
	private String name; // 名称
	private String color; // 颜色
	private Double weight; // 重量
	private Double price; // 价格

	public Apple(String name, String color, Double weight, Double price) {
		this.name = name;
		this.color = color;
		this.weight = weight;
		this.price = price;
	}

	// 为节省篇幅，此处省略每个成员属性的get/set方法

	// 获取该苹果的详细描述文字
	public String toString() {
		return String.format("\n(name=%s,color=%s,weight=%f,price=%f)", name,
				color, weight, price);
	}

	// 判断是否红苹果
	public boolean isRedApple() {
		return this.color.toLowerCase().equals("red");
	}
}

接着构建一个填入若干苹果信息的初始清单

// 获取默认的苹果清单
private static List<Apple> getAppleList() {
	// 数组工具Arrays的asList方法可以把一系列元素直接赋值给清单对象
	List<Apple> appleList = Arrays.asList(
					new Apple("红苹果", "RED", 150d, 10d), 
					new Apple("大苹果", "green", 250d, 10d),
					new Apple("红苹果", "red", 300d, 10d), 
					new Apple("大苹果", "yellow", 200d, 10d), 
					new Apple("红苹果", "green", 100d, 10d), 
					new Apple("大苹果", "Red", 250d, 10d));
	return appleList;
}

public interface Predicate<T> {
    boolean test(T t);
}

// 利用系统自带的断言接口Predicate，对某个清单里的元素进行过滤
private static <T> List<T> filterByPredicate(List<T> list, Predicate<T> p) {
	List<T> result = new ArrayList<T>();
	for (T t : list) {
		if (p.test(t)) { // 如果满足断言的测试条件，则把该元素添加到新的清单
			result.add(t);
		}
	}
	return result;
}

终于轮到外部调用刚才的过滤方法了，现在要求从原始的苹果清单中挑出所有的红苹果

// 测试系统自带的断言接口Predicate
private static void testPredicate() {
	List<Apple> appleList = getAppleList();
	// 第一种调用方式：匿名内部类实现Predicate。挑出所有的红苹果
	List<Apple> redAppleList = filterByPredicate(appleList, new Predicate<Apple>() {
		@Override
		public boolean test(Apple t) {
			return t.isRedApple();
		}
	});
	System.out.println("红苹果清单：" + redAppleList.toString());
}

显然匿名内部类的实现代码过于冗长，改写为Lambda表达式的话仅有以下一行代码：

// 第二种调用方式：Lambda表达式实现Predicate
List<Apple> redAppleList = filterByPredicate(appleList, t -> t.isRedApple());

或者采取方法引用的形式，也只需下列的一行代码：

// 第三种调用方式：通过方法引用实现Predicate
List<Apple> redAppleList = filterByPredicate(appleList, Apple::isRedApple);

11.1.2 消费接口Consumer

断言接口只进行逻辑判断，不涉及到数据修改，若要修改清单里的元素，就用到了另一个消费接口Consumer。

public interface Consumer<T> {
    void accept(T t);
}

定义泛型方法modifyByConsumer，根据输入的清单数据和消费实例，从而对清单执行指定的消费行为。

// 联合运用Predicate和Consumer，可筛选出某些元素并给它们整容
private static <T> void selectAndModify(List<T> list, Predicate<T> p, Consumer<T> c) {
	for (T t : list) {
		if (p.test(t)) { // 如果满足断言的条件要求，
			c.accept(t); // 就把该元素送去美容院整容。
		}
	}
}

// 联合测试断言接口Predicate和消费接口Consumer
private static void testPredicateAndConsumer() {
	List<Apple> appleList = getAppleList();
	// 如果是红苹果，就涨价五成
	selectAndModify(appleList, t -> t.isRedApple(), t -> t.setPrice(t.getPrice() * 1.5));
	// 如果重量大于半斤，再涨价五成
	selectAndModify(appleList, t -> t.getWeight() >= 250, t -> t.setPrice(t.getPrice() * 1.5));
	System.out.println("涨价后的苹果清单：" + appleList.toString());
}

11.1.3 函数接口Function

Function的定义代码可知，该接口不但支持输入某个泛型变量，也支持返回另一个泛型变量。

public interface Function<T, R> {
    R apply(T t);
}

编写新的泛型方法recycleByFunction，该方法输入原始清单和函数实例，输出处理后的新清单，从而满足了数据抽取的功能需求。详细的方法代码示例如下：

// 利用系统自带的函数接口Function，把所有元素进行处理后加到新的清单里面
private static <T, R> List<R> recycleByFunction(List<T> list, Function<T, R> f) {
	List<R> result = new ArrayList<R>();
	for (T t : list) {
		R r = f.apply(t); // 把原始材料t加工一番后输出成品r
		result.add(r); // 把成品r添加到新的清单
	}
	return result;
}

12、双冒号标记的方法引用

参考Java开发笔记（六十三）双冒号标记的方法引用

表达式“(str) -> str.isEmpty()”满足了下列三个条件：

里面的str为字符串String类型，并且式子右边调用的isEmpty正好属于字符串变量的方法；
式子左边有且仅有一个String类型的参数，同时式子右边有且仅有一行字符串变量的方法调用；
isEmpty的返回值为boolean布尔类型，Lambda表达式对应的匿名方法的返回值也是布尔类型；

String::isEmpty

String：参数类型
该表达式返回值类型：isEmpty的结果

若表达式需要传入参数：

String::endsWith, "y"

方法引用的条件非常严格，符合条件的表达式只能有方法自身，不允许出现其它额外的逻辑运算。被引用方法的输入参数尚能通过给过滤器添加参数来实现，多出来的逻辑运算可就无能为力了。不过对于字符串的筛选过程来说，更复杂的条件判断完全能够交给正则匹配方法matches，只要给定待筛选的字符串格式规则，那么matches方法就可以自动校验某个字符串是否符合正则条件了。假如要挑选首字母为w或者W的字符串数组，则采取方法引用的matches调用代码如下所示：

// 如需对字符串进行更复杂的条件筛选，可利用matches方法通过正则表达式来校验
resultArray = StringUtil.select2(strArray, String::matches, "[wW][a-zA-Z]*");
print(resultArray, "matches方法");

13、字符串String

13.1 调用String类的format方法进行字符串格式化之时，每种格式定义与数据类型是一一对应的

格式	数据类型
%d	整型
%s	字符串
%b	布尔值

13.2 把字符数组转成字符串

char[] temp = new char['a','b'];
String content = new String(temp); // 把数组转为字符串

14、使用option解决空指针异常问题

Optional本质上是一种特殊的容器，其内部有且仅有一个元素，同时该元素还可能为空。围绕着这个可空元素，Optional衍生出若干泛型方法，目的是将复杂的流程控制语句归纳为接续进行的方法调用。为了兼容已有的Java代码，通常并不直接构造Optional实例，而是调用它的ofNullable方法塞入某个实体对象，再调用Optional实例的其它方法进行处理。Optional常用的实例方法罗列如下：

方法	说明
get	获取可选器中保存的元素。如果元素为空，则扔出无此元素异常NoSuchElementException。
isPresent	判断可选器中元素是否为空。非空返回true，为空返回false。
ifPresent	如果元素非空，则对该元素执行指定的Consumer消费事件。
filter	如果元素非空，则根据Predicate断言条件检查该元素是否符合要求，只有符合才原样返回，若不符合则返回空值。
map	如果元素非空，则执行Function函数实例规定的操作，并返回指定格式的数据。
orElse	如果元素非空就返回该元素，否则返回指定的对象值。
orElseThrow	如果元素非空就返回该元素，否则扔出指定的异常。

举例：

常规的写法

// 判断是否红苹果
public boolean isRedApple() {
	// 常规的写法，判断color字段是否为空，再做分支处理
	boolean isRed = (this.color==null) ? false : this.color.toLowerCase().equals("red");
	return isRed;
}

Optional校验方式

// 把清单的非空判断代码改写为Optional校验方式
private static void getRedAppleWithOptionalTwo(List<Apple> list) {
	List<Apple> redAppleList = new ArrayList<Apple>();
	Optional.ofNullable(list) // 构造一个可空对象
		.ifPresent( // ifPresent指定了list非空时候的处理
			apples -> {
				apples.stream().forEach( // 对苹果清单进行流式处理
						item -> {
							if (Optional.ofNullable(item) // 构造一个可空对象
									.map(apple -> apple.isRedApple()) // map指定了item非空时候的取值
									.orElse(false)) { // orElse指定了item为空时候的取值
								redAppleList.add(item);
							}
						});
			});
	System.out.println("Optional2判断 红苹果清单=" + redAppleList.toString());
}

进一步优化，引入流式处理的filter方法替换if语句。

// 联合运用Optional校验和流式处理
private static void getRedAppleWithOptionalThree(List<Apple> list) {
	List<Apple> redAppleList = new ArrayList<Apple>();
	Optional.ofNullable(list) // 构造一个可空对象
			.ifPresent(apples -> { // ifPresent指定了list非空时候的处理
				// 从原始清单中筛选出红苹果清单
					redAppleList.addAll(apples.stream()
							.filter(a -> a != null) // 只挑选非空元素
							.filter(Apple::isRedApple) // 只挑选红苹果
							.collect(Collectors.toList())); // 返回结果清单
				});
	System.out.println("Optional3判断 红苹果清单=" + redAppleList.toString());
}

15、反射

15.1 通过反射来修改某个实例的私有属性

参考笔记

从Field对象挖掘出sex属性的数值，还得继续下列两个步骤的处理：

调用Field对象的setAccessible方法，并传入true值，表示将该字段设置为允许访问，以解除private的限制；
调用Field对象的getInt方法，并传入鸡类实例，表示准备从该示例中获取指定字段的整型值。同理调用getBoolean方法获取的是布尔值，调用getString方法获取的是字符串值。倘若是获取基本类型以外的类型值，则需先调用get方法获得Object对象，再强制转换为目标类型。

// 通过反射来修改某个实例的私有属性
private static void setReflectSex(Chicken chicken, int sex) {
	try {
		Class cls = Chicken.class; // 获得Chicken类的基因类型
		// 通过字段名称获取该类的字段对象
		Field sexField = cls.getDeclaredField("sex");
		if (sexField != null) {
			sexField.setAccessible(true); // 将该字段设置为允许访问
			sexField.setInt(chicken, sex); // 将某实例的该字段修改为指定数值
		}
	} catch (Exception e) { // 捕捉到了任何一种异常（错误除外）
		e.printStackTrace();
	}
}

注意：获取对象的所有属性使用getDeclaredFields（如果使用getFields，就无法获取到private的属性）

Field[] fields = cls.getDeclaredFields();

15.2 利用反射技术操作私有方法

（个人理解： 相当于可以访问私有方法，但是不能篡改该方法）
参考文章
参照私有属性的反射操作过程，私有方法的反射调用可分解为如下三个步骤：

调用Class对象的getDeclaredMethod方法，获取指定名称的方法对象，即Method对象；
调用Method对象的setAccessible方法，并传入true值，表示将该方法设置为允许访问，以解除private的限制；
调用Method对象的invoke方法，并传入鸡类实例，酌情填写输入参数；

示例：

// 通过反射来调用某个实例的私有方法（getSex方法）
private static int getReflectSex(Chicken chicken) {
	int sex = -1;
	try {
		Class cls = Chicken.class; // 获得Chicken类的基因类型
		// 通过方法名称及参数列表获取该方法的Method对象
		Method method = cls.getDeclaredMethod("getSex");
		method.setAccessible(true); // 将该方法设置为允许访问
		sex = (int) method.invoke(chicken); // 调用某实例的方法并获得输出参数
	} catch (Exception e) { // 捕捉到了任何一种异常（错误除外）
		e.printStackTrace();
	}
	return sex;
}

// 通过反射来调用某个实例的私有方法（setSex方法）
private static void setReflectSex(Chicken chicken, int sex) {
	try {
		Class cls = Chicken.class; // 获得Chicken类的基因类型
		// 通过方法名称及参数列表获取该方法的Method对象
		// 之所以需要参数类型列表，是因为同名方法可能会被多次重载，重载后的方法通过参数个数与参数类型加以区分
		Method method = cls.getDeclaredMethod("setSex", int.class);
		method.setAccessible(true); // 将该方法设置为允许访问
		method.invoke(chicken, sex); // 携带输入参数调用某实例的方法
	} catch (Exception e) { // 捕捉到了任何一种异常（错误除外）
		e.printStackTrace();
	}
}

注解	说明
@Override	方法重写
@FunctionalInterface	专门用来标记Java8规定的函数式接口。函数式接口是一类特殊的接口形式，它的内部有且仅有一个抽象方法，抽象方法多了不行，再来一个抽象方法的话，接口实例就没法简写为Lambda表达式，也就无法成为“函数式”接口。Java自带的几个函数式接口包括：比较器Comparator、断言接口Predicate、消费接口Consumer、函数接口Function、文件过滤器FileFilter、运行器Runnable等。
@Deprecated	过时的方法
@SupressWarnings	屏蔽警告
@SafeVarargs	兼容可变参数中的泛型参数，该注解告诉编译器：此处可变参数中的泛型是类型安全的，不必担心强制类型转换的问题。

注解	说明
@Documented	它修饰的注解将被收录到Java的开发文档中，这意味着程序员编码时的快捷提示会出现已收入的注解。
@Target	它修饰的注解将作用于哪一类的代码实体，例如ElementType.METHOD规定@Override对方法有效
@Retention	它修饰的注解将被编译器保留至哪个阶段
@Inherited	它修饰的注解将允许被子类所继承。通常情况下，一个注解加在某个类上面的话，它只对当前类有效，而对当前类的子类无效。

ElementType	说明
TYPE	类型，包括类、接口和枚举。
FIELD	字段，即类的属性。
METHOD	方法，但不包含构造方法。
PARAMETER	方法的参数。
CONSTRUCTOR	构造方法。
LOCAL_VARIABLE	局部变量。
ANNOTATION_TYPE	注解类型。
PACKAGE	包

Retention	说明
SOURCE	只在编码阶段保留
CLASS	保留在编译生成的class文件中，但不在运行时保留。这样从class文件反编译出来的源码仍可找到它所修饰的注解。
RUNTIME	一直保留至运行阶段。这样修饰后的注解可通过反射技术读取获得，以便代码在运行时动态校验注解。

方法	说明
exists	判断当前文件/目录是否存在，存在返回true，不存在返回false。
canExecute	判断当前文件是否允许执行，允许返回true，不允许返回false。
canRead	判断当前文件是否允许读取，允许返回true，不允许返回false。
canWrite	判断当前文件是否允许写入，允许返回true，不允许返回false。
isHidden	判断当前文件/目录是否隐藏，隐藏返回true，没隐藏返回false。
isDirectory	判断当前是否为目录，是返回true，否返回false。
isFile	判断当前是否为文件，是返回true，否返回false。

方法	说明
getAbsolutePath	获取当前文件/目录的绝对路径。
getPath	获取当前文件/目录的相对路径。
getName	如果当前为文件，则返回文件名称；如果当前为目录，则返回目录名称。
getParent	获取当前文件/目录的上级目录路径。
length	如果当前为文件，则返回文件大小；如果当前为空目录，则返回0；如果当前目录非空，则返回该目录的索引空间大小，索引保存了目录内部的文件基本信息。
lastModified	获取当前文件/目录的最后修改时间，单位毫秒。

方法	说明
mkdir	只创建最后一级目录，如果上级目录不存在就返回false。
mkdirs	创建文件路径中所有不存在的目录。
createNewFile	创建新文件。如果文件路径中的目录不存在，就会扔出异常IOException。
delete	删除文件，也可删除空目录，但不可删除非空目录。在删除非空目录时会返回false。
renameTo	文件重命名，把源文件的名称改为目标名称。

重载方法	返回内容
listFiles()	当前目录下的所有文件和目录
listFiles(FileFilter fileFilter)	根据文件信息筛选符合条件的文件和目录
listFiles(FilenameFilter filenameFilter)	根据文件信息和文件名称筛选符合条件的文件和目录，经常用于过滤特定扩展名的文件。

方法	说明
write	往文件写入字符串。注意该方法存在多个同名的重载方法
append	也是往文件写入字符串。按字面意思，append方法像是往文件末尾追加字符串，然而并非如此，append方法与write方法的写入位置是同样的。二者的区别在于，append方法会把空指针当作“null”写入文件，而write方法不支持写入空指针
close	关闭文件写入器

方法	说明
skip	跳过若干字符。注意FileReader的skip方法跳过的是字符数，不是字节数。
read	从文件读取数据到字节数组。注意该方法存在多个同名的重载方法。
close	关闭文件读取器。

方法	说明
newLine	往文件末尾添加换行标记（Window系统是回车加换行）。当然实际上是先往缓存添加换行标记，并非直接往磁盘写入换行标记。
flush	立即将缓冲区中的数据写入磁盘。默认情况要等缓冲区满了才会写入磁盘，或者调用close方法关闭文件之时也会写入磁盘，但是有时程序猴急，一定要立即写入磁盘，此时就需调用flush方法强行写磁盘。

方法	说明
readLine	从文件中读取一行数据。
mark	在当前位置做个标记。
reset	重置文件指针，令其回到上次标记的位置。也就是回到上次mark方法标记的文件位置。
lines	读取文件内容的所有行，返回的是Stream流对象，之后便可按照流式处理来加工该字符串流。

参数值	说明
r	以只读方式打开指定文件。如果试图对该文件执行write写入方法，则会抛出异常IOException。
rw	以可读且可写的方式打开指定文件。如果该文件不存在，则尝试创建新文件。
rws	以可读且可写的方式打开指定文件。rws模式的每次write方法都会立即写入文件，它相当于FileWriter
rwd	与rws模式类似。区别在于rwd只更新文件内容，不更新文件的元数据，而rws模式会同时更新文件内容及元数据。所谓元数据保存了文件的基本信息，包括文件类型（是文件还是目录）、文件的创建时间、文件的修改时间、文件的访问权限（是否可读、是否可写、是否可执行）等等。

方法	说明
length	获取指定文件的文件大小。
setLength	设置指定文件的文件大小。
seek	移动指定文件的访问位置。
write	往文件的当前位置写入字节数组。
read	把当前位置之后的文件内容读到字节数组。
close	关闭文件。RandomAccessFile拥有close方法，意味着它支持try-with-resources方式的自动释放资源。

方法	说明
skip	命令当前位置跳过若干字节，注意该方法跳过的是字节数而非字符数
available	返回文件当前位置后面的剩余部分大小，刚创建文件输入流对象之时调用available方法，得到的就是文件大小；如果先调用skip方法再调用available方法，得到的数值为文件大小减去跳过的字节数。

方法	说明
mark	在当前位置做个标记
reset	重置输入流指针，令其回到上次标记的位置。

方法	说明
Object.readObjectInputStream	从文件中读取对象信息
ObjectOutputStream.writeObject	将对象信息写入文件

工具类	说明	详细
GZIPOutputStream	压缩输出流	它吃进去的是原始数据的字节数组，拉出来的是字节数组输出流对象（压缩后的数据）。
ByteArrayOutputStream	字节数组输出流	它从压缩输出流获取压缩后的数据，并通过toByteArray方法输出字节数组信息。或者从压缩输入流获取解压后的数据，并通过toByteArray方法输出字节数组信息。
GZIPInputStream	压缩输入流	它吃进去的是字节数组输入流对象（压缩后的数据），拉出来的是解压后的字节数组（原始数据）。
ByteArrayInputStream	字节数组输入流	它输入压缩数据的字节数组，转成流对象后丢给压缩输入流。

方法	说明
isOpen	判断文件通道是否打开。
size	获取文件通道的大小（即文件长度）。
truncate	截断文件大小到指定长度。
read	把文件通道中的数据读到字节缓存。
write	往文件通道写入字节缓存中的数据。
force	强制写入磁盘，相当于缓存输出流的flush方法。
close	关闭文件通道。

方法	说明
clear	缓冲区数据写入通道之后，如果还想把新数据写入缓冲区，就要先调用clear方法清空它。
compact	只清除已经读过的数据，剩余的未读数据会移到缓冲区开头，新增的数据将加到未读数据后面。
flip	把缓冲区从写模式切换到读模式。从缓冲区读取数据之前，必须先调用flip方法。
rewind	让缓冲区的指针回到开头，以便重新再来一遍。

方法	limit	mark
clear	容量大小	-1
compact	容量大小	-1
flip	上次的当前位置	-1
rewind	保持不变	-1

Path的方法	说明
getParent	获取当前路径所在的上级目录的Path对象。
resolve	拼接文件路径，在当前路径的末尾添加指定字符串，并返回新的文件路径。
startsWith	判断当前路径是否以指定字符串开头。
endsWith	判断当前路径是否以指定字符串结尾。
toString	获取当前路径对应的名称字符串。
toFile	获取当前路径对应的File对象。

Paths的方法	说明
exists	判断该路径是否存在。
isDirectory	判断该路径是否为目录。
isExecutable	判断该路径是否允许执行。
isHidden	判断该路径是否隐藏。
isReadable	判断该路径是否可读。
isWritable	判断该路径是否可写。
size	获取该路径的文件大小。如果该路径是文件，则返回文件大小；如果该路径是目录，则返回目录基本信息的大小，而非整个目录的大小。
createDirectory	如果该路径是个目录，就创建新目录。
createFile	如果该路径是个文件，就创建新文件。
delete	如果该路径是文件或者空目录，就把它删掉。如果该路径不存在或者目录非空，就扔出异常。
deleteIfExists	如果该路径是文件或者空目录，就把它删掉（路径不存在也不报错）。但若目录非空，还是扔出异常。
copy	把文件从源路径复制到目标路径。
move	把文件从源路径移动到目标路径。

Paths方法（java8)	说明
readAllLines	获取该文件的所有内容行，返回的是字符串清单。
lines	获取该文件的所有内容行，返回的是字符串流Stream。
list	获取该目录下的所有文件与目录，但不包括子目录的下级内容，返回的是路径流Stream。
walk	获取该目录下的所有文件与目录，且包括指定深度子目录的下级内容，返回的是路径流Stream。

Java基础知识总结

Java基础知识总结

1、数组

1.1 Arrays.split(“”) 方法输入参数是正则串

2、正则表达式的保留字符

3、多态的理解

4、对象的类型检查

5、final修饰

6、内部类的创建实例

7、static修饰

7.1 静态代码块

7.2 静态属性的持久性

8、枚举

9、接口

9.1接口的成员变量

10、集合

10.1 Set集合

10.2 Map集合

11、泛型

11.1 Java8新增的几种泛型接口

11.1.1 断言接口Predicate

11.1.2 消费接口Consumer

11.1.3 函数接口Function

12、双冒号标记的方法引用

13、字符串String

13.1 调用String类的format方法进行字符串格式化之时，每种格式定义与数据类型是一一对应的

13.2 把字符数组转成字符串

14、使用option解决空指针异常问题

15、反射

15.1 通过反射来修改某个实例的私有属性

注意：获取对象的所有属性使用getDeclaredFields（如果使用getFields，就无法获取到private的属性）

15.2 利用反射技术操作私有方法

16、注解

16.1 系统自带注解

16.2 注解的基本单元——元注解

16.3 利用注解技术检查空指针

1. 自定义新的非空注解

2. 给非空字段添加非空注解

3. 利用反射机制校验被非空注解修饰了的所有字段

4. 在业务需要的地方调用校验方法

17、文件读写

17.1 文件与目录的管理

1、检查文件状态

2、获取文件信息

3、管理文件操作

4、遍历某目录下的文件

17.2 通过字符流读写文件

17.3 通过缓冲区读写文件

17.4 采用缓存读取器和缓存写入器逐行复制

17.5 RandomAccessFile 随机访问文件的读写

18、I/O流

18.1 文件字节I／O流

18.2 缓存字节I／O流

18.3 通过缓存输入和输出流复制文件

18.4 序列化

18.5 IO流处理简单的数据压缩

19、NIO——非阻塞的IO

19.1 文件通道的基本用法

19.2 深入理解字节缓存ByteBuffer

19.3 文件通道的性能优势

19.4 NIO配套的文件工具Files

20、线程

20.1 线程基本用法

20.2 利用Runnable启动线程

20.3 利用Callable启动线程

20.4 定时器与定时任务

21、并发

21.1 线程同步synchronized

21.2 通过加解锁避免资源冲突

21.3 线程间的通信方式

22、线程池

22.1 普通线程池的运用

22.2 几种定时器线程池

22.2 Fork+Join框架实现分而治之

23、数据格式

23.1 URL地址的组成格式

URL工具常用的方法：

域名的合法性校验：

常见字符对应的URL转义符：

23.2 JSON串的定义和解析

方法	说明
run	启动未来任务。
get	获取未来任务的执行结果。
isDone	判断未来任务是否执行完毕。
cancel	取消未来任务。
isCancelled	判断未来任务是否取消。

方法	说明
带两个参数的schedule方法	其中第一个参数为定时任务，第二个参数为任务的启动时间或者延迟启动间隔。这种schedule方法只会启动惟一一次定时任务。
带三个参数的schedule方法	其中第一个参数为定时任务，第二个参数为任务的启动时间或者延迟启动间隔，第三个参数为之后继续启动的时间间隔。这种schedule方法会持续不断地启动定时任务。下个任务要在上个任务结束之后再间隔若干时间才启动,下次启动时间与任务执行耗时有关
scheduleAtFixedRate	其中第一个参数为定时任务，第二个参数为任务的启动时间或者延迟启动间隔，第三个参数为之后每次启动的时间间隔。scheduleAtFixedRate方法也会持续不断地启动定时任务。下个任务不管上个任务何时结束，只要相互之间的启动间隔到达，即可立即启动下个任务。下次启动时间与任务耗时无关

方法	说明
lock	对可重入锁加锁。
unlock	对可重入锁解锁。
tryLock	尝试加锁。加锁成功返回true，加锁失败返回false。该方法与lock的区别在于：lock方法会一直等待加锁，而tryLock要求立刻加锁，要是加锁失败（表示之前已经被其它线程加了锁），就马上返回false，一会都等不了。
isLocked	判断该锁是否被锁住了。
getQueueLength	获取有多少个线程正在等待该锁的释放。

方法	说明
execute	将指定任务加入线程池
getCorePoolSize	获取核心的线程个数（即线程池的最小线程个数）。
getMaximumPoolSize	获取最大的线程个数（即线程池的最大线程个数）。
getPoolSize	获取线程池的当前大小（即线程池的当前线程个数）。
getTaskCount	获取所有的任务个数。
getActiveCount	获取活跃的线程个数。
getCompletedTaskCount	获取已完成的任务个数。
remove	从等待队列中移除指定任务。
shutdown	关闭线程池。关闭之后不能再往线程池中添加任务，不过要等已添加的任务执行完，才最终关掉线程池。用完后要关闭线程池，否则容易导致内存一直被消耗。
shutdownNow	立即关闭线程池。之后同样不能再往线程池中添加任务，同时会给已添加的任务发送中断信号，直到所有任务都退出才最终关掉线程池。
isShutdown	判断线程池是否已经关闭。

线程池对象的方法	说明	参数说明
schedule	定时任务只启动一次	第一个参数为任务实例，第二个和第三个参数分别是延迟执行的时长及其单位
scheduleAtFixedRate	每间隔若干时间周期启动定时任务	第一个参数为任务实例，第二个参数为首次执行的延迟时长，第三个参数分别为后续运行的间隔时长，第四个参数则为时长单位
scheduleWithFixedDelay	固定延迟若干时间启动定时任务	参数说明基本同scheduleAtFixedRate方法

方法	说明
execute	异步执行指定任务，且无返回值。
invoke	同步执行指定任务，并等待返回值，返回值就是最终的运算结果。
submit	异步执行指定任务，且返回结果任务对象。之后可择机调用结果任务的get方法获取最终的运算结果。

方法	说明
getProtocol	获取URL对象采用的网络协议。
getHost	获取URL对象的域名（主机名称）。
getDefaultPort	获取URL对象的默认端口。http协议的默认端口号是80，ftp协议的默认端口号是21，https协议的默认端口号是443。
getPort	获取URL对象的指定端口（若不显式指定则返回-1）。
getAuthority	获取URL对象的授权部门（由域名和指定端口组成）。
getPath	获取URL对象的路径（不包括域名）。
getQuery	获取URL对象的请求参数。
getFile	获取URL对象的文件名（由路径和请求参数组成）。
getRef	获取URL对象的引用位置。
openConnection	打开URL对象的网络连接，并返回URLConnection连接对象。无论是接口调用，还是上传下载，都依赖于这里的连接对象。

方法	说明
getString	获取指定键名的字符串。
getIntValue	获取指定键名的整型数。
getDoubleValue	获取指定键名的双精度数。
getBooleanValue	获取指定键名的布尔值。
getJSONObject	获取指定键名的JSONObject对象。
getJSONArray	获取指定键名的JSONArray数组。注意JSONArray类型派生自清单List，意味着可以把它当作清单一样读写。
put	添加指定的键值对信息。
remove	移除指定键名的键值对。
clear	清空当前的JSONObject对象。
toJSONString	把JSONObject对象转换为字符串。
parseObject	获得json串对应的JSONObject对象
toJavaObject	将json串自动转换成实体对象
toJSONString	把实体对象转换成对应的json串

方法	说明
getText	获得当前节点的字符串值。
element	获得当前节点下面指定名称的子节点对象。
elementText	获得当前节点下面指定名称的子节点值。
elements	获得当前节点下面指定名称的子节点清单。
attribute	获得当前节点自身指定名称的属性对象。
attributeValue	获得当前节点自身指定名称的属性值。
attributes	获得当前节点拥有的全部属性清单。

方法	说明
setRequestMethod	设置连接对象的请求方式，主要有GET和POST两种。
setConnectTimeout	设置连接的超时时间，单位毫秒。
setReadTimeout	设置读取应答数据的超时时间，单位毫秒。
connect	开始连接，之后才能获取该网址返回的应答报文信息。
disconnect	断开连接。
getResponseCode	获取应答的状态码。200表示成功，403表示禁止访问，404表示页面不存在，500表示服务器内部错误。
getInputStream	获取连接的输入流对象，从输入流中可读出应答报文。
getContentLength	获取应答报文的长度。
getContentType	获取应答报文的类型。
getContentEncoding	获取应答报文的编码方式。