tonglin0325的个人主页

Java基本语法笔记

tonglin0325

1.基本格式#

1
2
3
4
5
6
7
8
9
10
11
12
public class HelloWprdApp {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int num = 10;
        num = 30;
        System.out.println("num="+num);
        System.out.println("num*num="+num*num);
    }

}

String args[]：传统的写法，c、c++都用该种写法；

String[] args ：Java的写法，但Java也能用上面的方法定义。

实际上String[] args 是定义一字符串数组变量。

在java中，String[] args和String args[] 都可以定义数组。二者没有什么区别。为规范编码，推荐使用String[] args。另外args可以随意改，和其它变量一样，它只不过是一变量名，只要符合变量名规则即可。

 

打印语句：

1
2
3
System.Out.println("");　　带有换行　
System.Out.print("");　　不带有换行

java申明一个类的方法有两种：

public class　　类名称要和文件的名称一样，否则不能编译

class　　　　类名称可以和文件的名称不一样，编译时候生成的是 类名称.class

2.java基本数据类型#

数据类型 大小/位 可表示的数据范围 默认值
long(长整数) 64 -2^63～2^63-1 0L
int(整数) 32 -2^31～2^31-1-0x800000000x7FFFFFFF-21474836482147483647 0

-0x800000000x7FFFFFFF
|short(短整数)|16|-32768～32767|0
|byte(位)|8|-128127|0
|char(字符)|2|0~255|\u0000
|float(单精度)|32|-3.4E38～3.4E38|0.0f  　定义为float型的时候，数值的后面要加上f
|double(双精度)|64|-1.7E308～1.7E308|0.0d    注意使用浮点型数值的时候，默认使用的是double型，后面加上f的时候才使用float型
|boolean|1|flase true|flase

当数值发生溢出的时候，会形成循环，即最大值加上1后会变成最小值

强制转换类型的两种方法：

Integer.MAX_VALUE+2L　　　　在加的数字后面加上L表示强制转换成长整形

((long)Integer.MAX_VALUE+2)　　在加的数字前面加上long实现强制转换

 

如果需要精确的计算结果，则必须使用BigDecimal类，而且使用BigDecimal类也可以进行大数的操作。

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
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.math.BigDecimal;

class MyMath{
	public static double add(double d1, double d2){		//进行加法运算
		BigDecimal b1 = new BigDecimal(d1);
		BigDecimal b2 = new BigDecimal(d2);
		return b1.add(b2).doubleValue();
	}
	
	public static double sub(double d1, double d2){		//进行减法运算
		BigDecimal b1 = new BigDecimal(d1);
		BigDecimal b2 = new BigDecimal(d2);
		return b1.subtract(b2).doubleValue();
	}
	
	public static double mul(double d1, double d2){		//进行乘法运算
		BigDecimal b1 = new BigDecimal(d1);
		BigDecimal b2 = new BigDecimal(d2);
		return b1.multiply(b2).doubleValue();
	}
	
	public static double div(double d1, double d2,int len){		//进行除法运算
		BigDecimal b1 = new BigDecimal(d1);
		BigDecimal b2 = new BigDecimal(d2);
		return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue();	//表示四舍五入
	}
	
	public static double round(double d,int len){		//进行四舍五入
		BigDecimal b1 = new BigDecimal(d);
		BigDecimal b2 = new BigDecimal(1);						//任何一个数字除以1都是原数字
		return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue();	//表示四舍五入
	}
}

public class BigDecimal_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("加法运算："+MyMath.round(MyMath.add(10.345, 3.333), 1));
		System.out.println("加法运算："+MyMath.round(MyMath.sub(10.345, 3.333), 1));
		System.out.println("加法运算："+MyMath.div(10.345, 3.333, 1));
		System.out.println("加法运算："+MyMath.round(MyMath.mul(10.345, 3.333), 1));
	}

}

3.常用的转义字符#

转义字符 描述
\f 换页
*\* 反斜线
\b 倒退一格
' 单引号
\r 归位
" 双引号
\t 制表符tab
\n 换行

4.类型的转换#

**　　　当表示范围小的数值类型加上大的数值类型的时候，会自动转换成大的数值类型，比如short+int，会自动把结果转换成int型**

**　　　当数值类型加上字符串的时候，都转换成字符串类型**

5.数值格式化#

1.NumberFormat表示数字的格式化类，即可以按照本地的风格习惯进行数字的显示。

NumberFormat是一个抽象类，和MessageFormat类一样，都是Format类的子类，本类在使用时可以直接使用NumberFormat类中提供的静态方法为其实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.text.NumberFormat;

public class NumberFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		NumberFormat nf = null;
		nf = NumberFormat.getInstance();			//返回当前默认语言环境的数字格式
		System.out.println("格式化之后的数字："+nf.format(1000000));
		System.out.println("格式化之后的数字："+nf.format(1000.345));
	}

}

2.DecimalFormat类也是Format的一个子类，主要作用是格式化数字。

在格式化数字的时候比直接使用NumberFormat更加方便，因为可以直接指定按用户自定义的方式进行格式化操作，与SimpleDateFormat类似，如果要进行自定义格式化操作，则必须指定格式化操作的模板。

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
import java.text.DecimalFormat;

class FormatDemo{
	public void format1(String pattern,double value){
		DecimalFormat df = null;					//声明一个DecimalFormat对象
		df = new DecimalFormat(pattern);	//实例化对象
		String str = df.format(value);				//格式化数字
		System.out.println("使用"+pattern+"格式化数字"+value+":"+str);
	}
}

public class DecimalFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		FormatDemo demo = new FormatDemo();
		demo.format1("###,###.###", 111222.34567);
		demo.format1("000,000.000", 11222.34567);
		demo.format1("###,###.###￥", 111222.34567);
		demo.format1("##.###%", 0.34567);			//使用百分数形式
		demo.format1("00.###%", 0.034567);			//使用百分数形式
		demo.format1("###.###\u2030", 0.34567);	//使用千分数形式
	}

}

6.java枚举类型Enum#

在JDK5中引入了一个新的关键字——enum，可以直接定义枚举类型

在申明枚举类的时候，也可以申明属性、方法和构造函数，但枚举类的构造函数必须为私有的，不然就能new出枚举类

取出一个枚举内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum Color{
	RED,GREEN,BLUE;
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Color c = Color.BLUE;
		System.out.println(c);
	}

}

枚举类型的数据也可以使用“枚举.values()”的形式，将全部的枚举类型变为对喜爱数组的形式，之后再直接使用foreach进行输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
enum Color{
	RED,GREEN,BLUE;
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(Color c:Color.values()){
			System.out.println(c);
		}
	}

}

使用switch进行判断

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
34
35
36
enum Color{
	RED,GREEN,BLUE;
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(Color c:Color.values()){
			print(c);
		}
	}
	
	public static void print(Color color){
		switch(color){
			case RED:{
				System.out.println("红色");
				break;
			}
			case GREEN:{
				System.out.println("绿色");
				break;
			}
			case BLUE:{
				System.out.println("蓝色");
				break;
			}
			default:{
				System.out.println("其他颜色");
				break;
			}
		}
	}

}

使用name()和ordinal()方法取得名称和编号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
enum Color{
	RED,GREEN,BLUE;
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(Color c:Color.values()){
			System.out.println(c.ordinal()+"-->"+c.name());
		}
	}

}

** 通过构造方法为属性赋值**

通过把构造方法私有，使得不能new 一个新的Color对象，只能使用RED(“红色”),GREEN(“绿色”),BLUE(“蓝色”)三个类型

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
enum Color{
	RED("红色"),GREEN("绿色"),BLUE("蓝色");		//定义枚举的3个类型，“红色”对应String name
	
	private Color(String name){			//定义私有构造方法
		this.setName(name);
	}
	
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(Color c:Color.values()){
			System.out.println(c.ordinal()+"-->"+c.name()+c.getName());
		}
	}

}

通过setter()方法为属性赋值

 

 

枚举比较器

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
34
35
36
37
38
39
40
41
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

enum Color{
	RED("红色"),GREEN("绿色"),BLUE("蓝色");		//定义枚举的3个类型
	
	private Color(String name){			//定义构造方法
		this.setName(name);
	}
	
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

public class Enum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Set<Color> t = new TreeSet<Color>();
		t.add(Color.BLUE);
		t.add(Color.GREEN);
		t.add(Color.RED);
		Iterator<Color> iter = t.iterator();
		while(iter.hasNext()){
			System.out.println(iter.next()+"、");
		}
	}


}

 

EnumMap

EnumMap是Map接口的子类，所以本身还是以Map的形式进行操作，即Key–Value，

如果要使用EnumMap，则首先要创建EnumMap的对象，在创建对象的时候必须指定要操作的枚举类型

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
import java.util.EnumMap;
import java.util.Map;

enum color{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumMap_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Map<Color,String> desc = null;									//定义一个Map对象
		desc = new EnumMap<Color,String>(Color.class);	//实例化EnumMap
		desc.put(Color.BLUE, "蓝色");
		desc.put(Color.RED, "红色");
		desc.put(Color.GREEN,"绿色");
		
		for(Color c:Color.values()){				//取得全部的枚举
			System.out.println(c.name()+"-->"+c.getName());
		}
		
		for(Color c:desc.keySet()){				//取得全部的Key
			System.out.println(c.name()+"、");
		}
		
		for(String c:desc.values()){				//取得全部的值
			System.out.println(c+"、");
		}
	}

}

 

EnumSet

EnumSet是Set接口的子类，所以里面的内容是无法重复的。

使用EnumSet时不能直接使用关键字new为其进行实例化，所以在此类中提供了很多的静态方法

 

EnumSet—将全部的集合设置到EnumSet集合中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.EnumSet;

enum color_{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		EnumSet<Color> es = null;				//声明一个EnumSet对象
		es = EnumSet.allOf(Color.class);		//将枚举的全部类型设置到EnumSet对象中
		
		print(es);
	}
	
	public static void print(EnumSet<Color> temp){		//专门的输出操作
		for(Color c:temp){															//循环输出EnumSet中的内容
			System.out.println(c+"、");
		}
	}

}

 

只设置一个枚举的类型到集合中

使用EnumSet提供的static方法of()，将一个枚举中的一个内容设置到EnumSet集合中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.EnumSet;

enum color_{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		EnumSet<Color> es = null;				//声明一个EnumSet对象
		es = EnumSet.of(Color.BLUE);			//设置一个枚举的内容
		
		print(es);
	}
	
	public static void print(EnumSet<Color> temp){		//专门的输出操作
		for(Color c:temp){															//循环输出EnumSet中的内容
			System.out.println(c+"、");
		}
	}

}

 

创建只能放入指定枚举类型的集合

使用EnumSet提供的static方法noneOf()，将集合设置成只能增加Color类型的集合，但是并不设置任何的内容到集合中

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
import java.util.EnumSet;

enum color_{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		EnumSet<Color> es = null;				//声明一个EnumSet对象
		
		es = EnumSet.noneOf(Color.class);			//创建一个可以加入Color类型的对象
		es.add(Color.BLUE);
		es.add(Color.RED);
		
		print(es);
	}
	
	public static void print(EnumSet<Color> temp){		//专门的输出操作
		for(Color c:temp){															//循环输出EnumSet中的内容
			System.out.println(c+"、");
		}
	}

}

 

创建不包含指定元素的集合

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
import java.util.EnumSet;

enum color_{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		EnumSet<Color> esOld = null;				//声明一个EnumSet对象
		EnumSet<Color> esNew = null;				//声明一个EnumSet对象
		esOld = EnumSet.noneOf(Color.class);			//创建一个可以加入Color类型的对象
		esOld.add(Color.BLUE);
		esOld.add(Color.RED);
		esNew = EnumSet.complementOf(esOld);		//创建一个不包含指定元素的集合
		print(esNew);
	}
	
	public static void print(EnumSet<Color> temp){		//专门的输出操作
		for(Color c:temp){															//循环输出EnumSet中的内容
			System.out.println(c+"、");
		}
	}

}

 

复制已有的内容

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
import java.util.EnumSet;

enum color_{
	RED,GREEN,BLUE;		//定义枚举的3个类型
}	

public class EnumSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		EnumSet<Color> esOld = null;				//声明一个EnumSet对象
		EnumSet<Color> esNew = null;				//声明一个EnumSet对象
		esOld = EnumSet.noneOf(Color.class);			//创建一个可以加入Color类型的对象
		esOld.add(Color.BLUE);
		esOld.add(Color.RED);

		esNew = EnumSet.copyOf(esOld);					//从已有的集合中复制出内容
		print(esNew);
	}
	
	public static void print(EnumSet<Color> temp){		//专门的输出操作
		for(Color c:temp){															//循环输出EnumSet中的内容
			System.out.println(c+"、");
		}
	}

}

 

让枚举类实现一个接口

在接口中定义了一个getColor()方法，枚举类在实现此接口之后，就必须对枚举类中的每个对象分别实现接口中的getColor()方法

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
34
35
36
37
38
39
interface Print_{	//定义Print方法
	public String getColor();	//定义抽象方法
}

enum color_1 implements Print_{	//枚举类实现接口
	RED{	//枚举对象实现抽象方法
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "红色";
		}
	},
	BLUE{
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "蓝色";
		}
	},
	GREEN{
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "绿色";
		}
	};
}	

public class InterfaceEnum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(color_1 c:color_1.values()){	//循环输出EnumSet中的内容
			System.out.println(c.getColor()+"、");
		}
	}

}

 

在枚举类中定义抽象方法

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
interface Print_{	//定义Print方法
	public String getColor();	//定义抽象方法
}

//enum color_1 implements Print_{	//枚举类实现接口
//	RED{	//枚举对象实现抽象方法
//		@Override
//		public String getColor() {
//			// TODO 自动生成的方法存根
//			return "红色";
//		}
//	},
//	BLUE{
//		@Override
//		public String getColor() {
//			// TODO 自动生成的方法存根
//			return "蓝色";
//		}
//	},
//	GREEN{
//		@Override
//		public String getColor() {
//			// TODO 自动生成的方法存根
//			return "绿色";
//		}
//	};
//}	

enum color_1{	//枚举类实现接口
	RED{	//枚举对象实现抽象方法
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "红色";
		}
	},
	BLUE{
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "蓝色";
		}
	},
	GREEN{
		@Override
		public String getColor() {
			// TODO 自动生成的方法存根
			return "绿色";
		}
	};
	public abstract String getColor();	//定义抽象方法
}	


//主类
//Function        : 	InterfaceEnum_demo;
public class InterfaceEnum_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for(color_1 c:color_1.values()){	//循环输出EnumSet中的内容
			System.out.println(c.getColor()+"、");
		}
	}

}

7.位运算符#

|位运算符|描述
|&|按位与
|||按位或
|^|异或（相同为0，不同为1）
|～|取反
|<<**|**左移位**
|**>>|右移位　　正数右移的时候左边补零，负数左边补一
|>>>|无符号移位　　正数负数右移的时候左边都补零

数组中，数组的名字，即地址存在栈内存中，地址指向的内容存在堆内存中，开辟新的堆内存必须要用关键字new，栈内存中存储的是堆内存的访问地址

当堆空间没有任何栈空间引用的时候，就成为了垃圾空间，等待这垃圾回收机制进行回收

数组的复制：System.arraycopy（i1,3,i2,1,3）源数组名称　　源数组开始点　　目标数组名称　　目标数组开始点　　复制长度

8.逻辑运算符优先级#

9.方法的定义方式#

1
2
3
4
public static void 方法名字（类型 参数，类型 参数。。。）{
　　程序语句
}

10.可变参数#

1
2
3
4
5
6
7
8
9
　　fun();
　　fun(1);
　　fun(1,2,3,4,5);

　　public static void fun(int... arg){
　　　　for(int i=0;i<arg.lenght;i++){
　　　　　　system.out.print(arg[i]+"、");
　　}

11.类的定义#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Person{
　　　　private string name;//把属性封装，讲不能通过XX.name访问，必须通过setter和getter方法设置和取得
　　　　private int age;//private也可以用-表示
 
　　　　public Person(String name,int age){　//构造函数，和类名同名
　　　　　　this.setName(name);
　　　　　　this.setAge(age);
　　　　}

　　　　public void tell(){
　　　　　　system.out.println();
　　　　}
}

对象的创建和使用

**　　类名 对象名称 = null;
**

**　　对象名称 = new 类名();**

或者

**　　类名 对象名称 = new 类名();
**

匿名对象

**　　new Person(“张三”,30).tell();//匿名对象，匿名对象一般是作为其他类实例化对象的参数传递，匿名对象是一个堆内存空间，没有栈空间
**

 

类设计分析

<1>根据要求写出类所包含的属性

<2>所有的属性都必须进行封装(private)

<3>封装之后的属性通过setter和getter设置和取得

<4>如果需要可以加入若干构造方法

<5>再根据其他要求添加相应的方法

<6>类中的所有方法都不要直接输出，而是交给被调用处输出

<7> 永远不要继承一个已经实现好的类，只能继承抽象类或者实现接口，因为一旦发生对象的向上转型关系后，所调用的方法一定是被子类所覆写的方法

12.string对象#

使用==比较string对象的时候比较的是string的地址

使用.equals方法比较的是string对象的内容

 

<1>使用string str = new string(“hello”);创建一个新的string对象，”hello”创建一个对象，new关键字又创建一个对象，所以建议使用第二种方法创建对象

<2>string str = “hello”;

 

注意：字符串的内容不可以修改，所以要避免对字符串的内容进行连续的修改，因为修改一次就要开辟两个新的内存空间，通过断开和连接进行字符串的修改。

要通过StringBuffer类进行修改。

13.引用#

所谓引用传递就是指将堆内存空间的使用权交给多个栈内存空间。

例子<1>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Aliasing {
	int temp = 30;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Aliasing d1 = new Aliasing();
		d1.temp = 50;
		System.out.println(d1.temp);
		fun(d1);
		System.out.println(d1.temp);
	}
	
	public static void fun (Aliasing d2){
		d2.temp = 1000;
	}
}

 

 例子<2> 其中传递的是string对象，由于string的内容是不可以修改，所以str1的值还是hello，如果传递的是对象的string属性，那是可以修改的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Aliasing {
	int temp = 30;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String str1 = "hello";
		System.out.println(str1);
		fun(str1);
		System.out.println(str1);
	}
	
	public static void fun (String str2){
		str2 = "hello2";
	}
}

 

 

例子<3>传递的是对象的string属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Aliasing {
	String temp = "hello";
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Aliasing d1 = new Aliasing();
		d1.temp = "world";
		System.out.println(d1.temp);
		fun(d1);
		System.out.println(d1.temp);
	}
	
	public static void fun (Aliasing d2){
		d2.temp="HELLO";
	}
}

 

 

一对一关系   例子

一个人对应一本书，一本书对应一个人

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
class Person{
		private String name;
		private int age;
		private Book book;
		
		public Person(String name,int age){
			this.setName(name);
			this.setAge(age);
		}
		
		public  String getName(){
			return name;
		}

		public void setName(String n){
			name = n;
		}
		
		public int getAge(){
			return age;
		}
		
		public void setAge(int a){
			age = a;
		}
		
		public Book getBook(){
			return book;
		}
		
		public void setBook(Book b){
			book = b;
		}
}

class Book{
	private String title;
	private float price;
	private Person person;
	
	public Book(String title,float price){
		this.setTitle(title);
		this.setPrice(price);
	}
	
	public  String getTitle(){
		return title;
	}

	public void setTitle(String t){
		title = t;
	}
	
	public float getPrice(){
		return price;
	}
	
	public void setPrice(float p){
		price = p;
	}
	
	public Person getPerson(){
		return person;
	}
	
	public void setPerson(Person person){
		this.person = person;
	}
	
}


public class reference {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Person per = new Person("zhangsan",30);
		Book bk = new Book("JAVA SE kaifa",90.0f);
		per.setBook(bk);
		bk.setPerson(per);
		System.out.println(" name "+per.getName()+" age "+per.getAge()+" book "+per.getBook().getTitle()+" price "+per.getBook().getPrice());
		System.out.println(" title "+bk.getTitle()+" price "+bk.getPrice()+" person "+bk.getPerson().getName()+" age "+bk.getPerson().getAge());
	}

}

 一个人对应一本书，一本书对应一个人，一个孩子对应一本书，一本书对应一个孩子，一个人对应一个孩子

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
class Person{
		private String name;
		private int age;
		private Book book;
		private Person child;
		
		public Person(String name,int age){
			this.setName(name);
			this.setAge(age);
		}
		
		public  String getName(){
			return name;
		}

		public void setName(String n){
			name = n;
		}
		
		public int getAge(){
			return age;
		}
		
		public void setAge(int a){
			age = a;
		}
		
		public Book getBook(){
			return book;
		}
		
		public void setBook(Book b){
			book = b;
		}
		
		public Person getChild(){
			return child;
		}
		
		public void setChild(Person child){
			this.child = child;
		}
}

class Book{
	private String title;
	private float price;
	private Person person;
	
	public Book(String title,float price){
		this.setTitle(title);
		this.setPrice(price);
	}
	
	public  String getTitle(){
		return title;
	}

	public void setTitle(String t){
		title = t;
	}
	
	public float getPrice(){
		return price;
	}
	
	public void setPrice(float p){
		price = p;
	}
	
	public Person getPerson(){
		return person;
	}
	
	public void setPerson(Person person){
		this.person = person;
	}
	
}

public class reference {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Person per = new Person("zhangsan",30);
		Person cld = new Person("zhangcao",10);
		Book bk = new Book("JAVA SE kaifa",90.0f);
		Book b = new Book("11111",30.0f);
		per.setBook(bk);
		bk.setPerson(per);
		cld.setBook(b);
		b.setPerson(cld);
		per.setChild(cld);
		System.out.println(" name "+per.getName()+" age "+per.getAge()+" book "+per.getBook().getTitle()+" price "+per.getBook().getPrice());
		System.out.println(" title "+bk.getTitle()+" price "+bk.getPrice()+" person "+bk.getPerson().getName()+" age "+bk.getPerson().getAge());
		System.out.println(" cldname "+per.getChild().getName()+" age "+per.getChild().getAge()+" book "+per.getChild().getBook().getTitle()+" price "+per.getChild().getBook().getPrice());
	}

}

14.构造方法#

识别合法的构造方法：

  1. 构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行;

重载：方法的重载(overload)；重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载.

  1. 当一个类中没有定义任何构造方法，Java将自动提供一个缺省的构造方法

  2. 子类通过super关键字调用父类的一个构造方法

  3. 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法

  4. 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰;

  5. 构造方法不是类的成员方法

  6. 构造方法不能被继承

15.Collections接口#

<1>实例操作一：返回不可变的集合

Collections类中可以返回空的List、Set、Map集合，但是通过这种方式返回的对象是无法进行增加数据的，因为在这些操作中并没有实现add()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Collections;
import java.util.List;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		List<String> allList = Collections.emptyList();			//返回不可变的空List集合
		Set<String> allSet = Collections.emptySet();			//返回不可变的空List集合
	}

}

 

<2>实例操作二：为集合增加内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
	}

}

 

<3>实例操作三：反转集合中的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		Collections.reverse(all);											//内容反转保存
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
	}

}

 

<4>实例操作四：检索内容

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
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		Collections.reverse(all);											//内容反转保存
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
		int point = Collections.binarySearch(all,"zhangsan");
		System.out.println("检索结果："+point); 			//输出位置
		
	}

}

 

<5>实例操作五：替换集合中的内容

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
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		List<String> allList = Collections.emptyList();			//返回不可变的空List集合
//		Set<String> allSet = Collections.emptySet();			//返回不可变的空List集合
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		
		Collections.replaceAll(all, "wangwu", "lisi");			//替换内容
		
		Collections.reverse(all);											//内容反转保存
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
		int point = Collections.binarySearch(all,"zhangsan");
		System.out.println("检索结果："+point); 			//输出位置
		
	}

}

 

<6>实例操作六：集合排序

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
34
35
36
37
38
39
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		List<String> allList = Collections.emptyList();			//返回不可变的空List集合
//		Set<String> allSet = Collections.emptySet();			//返回不可变的空List集合
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		
//		Collections.replaceAll(all, "wangwu", "lisi");			//替换内容
		
//		Collections.reverse(all);											//内容反转保存
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
		Collections.sort(all);
		System.out.println("排序之后的集合");
		iter = all.iterator();
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
		int point = Collections.binarySearch(all,"zhangsan");
		System.out.println("检索结果："+point); 			//输出位置
		
	}

}

 

<7>实例操作七：交换指定位置的内容

直接使用swap()方法可以把集合中两个位置的内容进行交换

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
34
35
36
37
38
39
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Collection_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		List<String> allList = Collections.emptyList();			//返回不可变的空List集合
//		Set<String> allSet = Collections.emptySet();			//返回不可变的空List集合
		
		List<String> all = new ArrayList<String>();			//实例化List
		Collections.addAll(all, "zhangsan","lisi","wangwu");		//增加内容
		
//		Collections.replaceAll(all, "wangwu", "lisi");			//替换内容
		
//		Collections.reverse(all);											//内容反转保存
		Iterator<String> iter = all.iterator();					//实例化iterator对象
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
//		Collections.sort(all);
		Collections.swap(all,0,2);		//交换指定位置的内容
		System.out.println("排序之后的集合");
		iter = all.iterator();
		while(iter.hasNext()){
		System.out.println(iter.next()+"、");
		}
		
		int point = Collections.binarySearch(all,"zhangsan");
		System.out.println("检索结果："+point); 			//输出位置
		
	}

}

16.List接口#

List是Collection的子接口，其中可以保存各个重复的内容。

 

List接口的常用子类

1.ArrayList

<1>实例操作一：向集合中增加元素

<2>实例操作二：删除元素

<3>实例操作三：输出List中的内容

<4>实例操作四：将集合变为对象数组

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class List_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		List<String> allList = null;			//定义List对象
		Collection<String> allCollection = null;		//定义Collection对象
		allList = new ArrayList<String>();						//实例化List对象，只能是String类型
		allCollection = new ArrayList<String>();			//实例化Collection，只能是String类型
		
		allList.add("Hello");				//是从Collection继承的方法
		allList.add(0,"Word");			//此方法为List扩充的方法
		System.out.println(allList); 	//输出集合中的内容
		
		allCollection.add("zhangsan");				//增加数据
		allCollection.add("www.baidu.com");			//增加数据
		
		allList.addAll(allCollection);				//是从Collection继承的方法，增加一组对象
		allList.addAll(0,allCollection);				//是从Collection继承的方法，增加一组对象
		System.out.println(allList); 	//输出集合中的内容
		
		allList.remove(0);		//删除指定位置的元素
		allList.remove("Hello");		//删除指定内容的元素
		System.out.println(allList); 	//输出集合中的内容
		
		System.out.println("从前向后输出：");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"、");
		}
		
		System.out.println("从后向前输出：");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"、");
		}
		
		String str[]  =allList.toArray(new String[] {});		//指定的泛型类型
		System.out.println("转换为数组类型");
		for(int i =0;i<str.length;i++){
			System.out.println(str[i]+"、");
		}
		
		System.out.println("返回对象数组");
		Object obj[] = allList.toArray();
		for(int i =0;i<obj.length;i++){
			String temp = (String) obj[i];
			System.out.println(temp+"、");
		}
		
		System.out.println(allList.contains("zhangsan")?"字符串存在":"字符串不存在");
		List<String> allSub = allList.subList(0, 2);		//取出里面的部分集合,前两个
		System.out.println(allSub); 	//输出集合中的内容
		System.out.println("字符串的位置"+allList.indexOf("zhangsan"));	//查询字符串的位置
		System.out.println("集合操作后是否为空？"+allList.isEmpty());
	}

}

 

2.LinkedList子类与Queue接口

LinkedList表示的是一个链表的操作类，即Java中已经为开发者提供好了一个链表程序，开发者直接使用即可，无需再重新开发。

 

<1>实例操作一：在链表的开头和结尾增加数据

<2>实例操作二：找到链表头

<3>实例操作三：以先进先出的方式取出全部的数据

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
34
import java.util.LinkedList;

public class LinkedList_demo {

	public static void main(String[] args) {
			// TODO 自动生成的方法存根
			LinkedList<String> link = new LinkedList<String>();
			link.add("A");
			link.add("B");
			link.add("C");
			System.out.println("初始化链表："+link);  //输出链表内容，调用toString
			
			link.addFirst("X");
			link.addLast("Y");
			System.out.println("添加头尾之后的链表："+link);  //输出链表内容，调用toString
			
			System.out.println("使用element()方法找到表头："+link.element());
			System.out.println("找到之后的link内容"+link);
			
			System.out.println("使用peek()方法找到表头："+link.peek());
			System.out.println("找到之后的link内容"+link);
			
			System.out.println("使用poll()方法找到表头："+link.poll());
			System.out.println("找到之后的link内容"+link);
			
			System.out.println("以先进先出的方式输出：");
			for(int i=0;i<link.size()+1;i++){
				System.out.println(link.poll()+"、");
			}
	}
	

}

 

在类集中提供了以下4种常见的输出方式。

**Iterator:**迭代输出，是使用最多的输出方式

**ListIterator:**是Iterator的子接口，专门用于输出List的内容

**Enumeration:**是一个旧的接口，功能与Iterator类似

**foreach:**JDK1.5之后提供的新功能，可以输出数组或者集合

 

Iterator:迭代输出

碰到集合输出的操作，就一定使用Iterator接口

所谓的迭代输出接口就是将元素一个个进行判断，判断其是否有内容，如果有内容则把内容取出。

<1>实例操作一：输出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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class Iterator_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		List<String> all = new ArrayList<String>();		//实例化List接口
		all.add("A");
		all.add("C");
		all.add("D");
		all.add("E");
		all.add("B");
		Iterator<String> iter = all.iterator();				//直接实例化Iterator接口
		while(iter.hasNext()){										//依次判断
			System.out.println(iter.next()+"、"); 			//输出内容
		}
	}

}

 <2>实例操作二：使用Iterator删除指定内容

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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class Iterator_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		List<String> all = new ArrayList<String>();		//实例化List接口
		all.add("A");
		all.add("C");
		all.add("D");
		all.add("E");
		all.add("B");
		Iterator<String> iter = all.iterator();				//直接实例化Iterator接口
		while(iter.hasNext()){										//依次判断
			String str = iter.next();									//取出内容
			if("A".equals(str)){
				iter.remove();
			}else{
			System.out.println(str+"、"); 			//输出内容
			}
		}
	}

}

 

ListIterator:双向迭代输出 

ListIterator接口的主要功能是由前向后单向输出，而此时如果想实现有后向前或是由前向后的双向输出，则必须使用Iterator接口的子接口——ListIterator。

<1>进行双向迭代

<2>增加及代替元素

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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		List<String> all = new ArrayList<String>();		//实例化List接口
		
		all.add("C");
		all.add("D");
		all.add("E");
		all.add("A");
		all.add("B");
		ListIterator<String> iter = all.listIterator();				//实例化ListIterator接口
		System.out.println("由前向后输出："); 					//信息输出
		while(iter.hasNext()){										//依次判断
			String str = iter.next();									//取出内容
			System.out.println(str+"、"); 			//输出内容
			iter.set("LIN-"+str);									//替换元素
		}
		
		System.out.println("由后向前输出："); 					//信息输出
		iter.add("TONY"); 														//增加元素
		while(iter.hasPrevious()){										//依次判断
			String str = iter.previous();									//取出内容
			System.out.println(str+"、"); 			//输出内容
		}
	}

}&nbsp;

17.Set接口#

Set接口也是Collection接口的子接口，Set接口中不能加入重复的元素

Set接口的常用子类

1、散列的存放：HashSet

HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复的元素，而且采用散列的存储方式，所以没有顺序。

2、有序的存放：TreeSet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;
import java.util.TreeSet;

public class Set_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Set<String> allSet = new HashSet<String>();		//无序
		Set<String> allSet = new TreeSet<String>();		//有序
		allSet.add("A");
		allSet.add("C");
		allSet.add("D");
		allSet.add("E");
		allSet.add("B");

		System.out.println(allSet);  //输出集合内容，调用toString
	}

}

 

TreeSet中实现了SortedSet接口，此接口主要用于排序操作，即实现此接口的子类都属于排序的子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSet_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		SortedSet<String> allSet = new TreeSet<String>();		//有序
		allSet.add("A");
		allSet.add("C");
		allSet.add("D");
		allSet.add("E");
		allSet.add("B");

		System.out.println("第一个元素："+allSet.first());
		System.out.println("最后一个元素："+allSet.last()); 			
		System.out.println("headSet元素："+allSet.headSet("c")); 			
		System.out.println("tailSet元素："+allSet.tailSet("C")); 
		System.out.println("subSet元素："+allSet.subSet("B","D"));
	}

}

18.Map接口#

Collection、Set、List接口都属于单值的操作，即每次只能操作一个对象，

而Map与他们不同的是，每次操作的是一对对象，即二元偶对象，Map中的每个元素都使用key->value的形式存储在集合中。

 

<1>实例操作一：向集合中增加和取出内容

在Map接口中使用put(Object key,Object value)方法可以向集合中增加内容，之后通过get(E key)方法根据key找到其对应的value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.HashMap;
import java.util.Map;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Map<String,String> map = null;	　　　　　//声明Map对象
		map = new HashMap<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");　　　//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
		String val = map.get("zhangsan");
		
		System.out.println("取出内容："+val);
	}	

}

 

<2>实例操作二：判断指定的key或者value是否存在

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
import java.util.HashMap;
import java.util.Map;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Map<String,String> map = null;		//声明Map对象
		map = new HashMap<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");	//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
		String val = map.get("zhangsan");
		
		System.out.println("取出内容："+val);
		
		if(map.containsKey("zhangsan")){		//查找指定的key
			System.out.println("搜索的key存在");
		}else{
			System.out.println("搜索的key不存在");
		}
		if(map.containsValue("www.baidu.com")){		//查找指定的value
			System.out.println("搜索的value存在");
		}else{
			System.out.println("搜索的value不存在");
		}
	}	

}

 

<3>实例操作三：输出全部的key

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
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;		//声明Map对象
		map = new HashMap<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");	//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
		
		Set<String> keys = map.keySet();		//取得所有的key
		Iterator<String> iter = keys.iterator();	//实例化Iterator
		
		System.out.println("全部的key：");
		while(iter.hasNext()){
			String str = iter.next();		//取出集合的key
			System.out.println(str+"、");
		}
	}	

}

 

<4>实例操作三：输出全部的value

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;		//声明Map对象
		map = new HashMap<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");	//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
			
		Collection<String> values = map.values();		//取得所有的value
		Iterator<String> iter = values.iterator();		//实例化Iterator
		System.out.println("全部的values：");
		while(iter.hasNext()){
			String str = iter.next();			//取出集合的key
			System.out.println(str+"、");
		}
	}	

}

 

旧的子类：Hashtable

Hashtable也是Map中的一个子类，属于旧的操作类

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
34
35
36
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;		//声明Map对象
		map = new Hashtable<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");	//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
		
		Set<String> keys = map.keySet();		//取得所有的key
		Iterator<String> iter = keys.iterator();	//实例化Iterator
		System.out.println("全部的key：");
		while(iter.hasNext()){
			String str = iter.next();		//取出集合的key
			System.out.println(str+"、");
		}
		Collection<String> values = map.values();	//取得所有的value
		Iterator<String> iter2 = values.iterator();	//实例化Iterator
		System.out.println("全部的values：");
		while(iter2.hasNext()){
			String str = iter2.next();		//取出集合的value
			System.out.println(str+"、");
		}
	}	

}

 

 

排序的子类：TreeMap

排序后输出

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;		//声明Map对象
		map = new TreeMap<String,String>();	//实例化Map对象
		map.put("B", "www.baidu.com");	　　　　//增加内容
		map.put("A", "www.alibaba.com");	//增加内容
		map.put("C", "www.google.com");	　　　　//增加内容
		Set<String> keys = map.keySet();		//取得所有的key
		Iterator<String> iter = keys.iterator();	//实例化Iterator
		System.out.println("全部的key：");
		while(iter.hasNext()){
			String str = iter.next();		//取出集合的key，排序后输出
			System.out.println(str+"、");
		}
	}	

}

 

 弱引用类：WeakHashMap

之前的Map子类中的数据都是使用强引用保存的，即里面的内容不管是否使用都始终在集合中保留，如果希望集合自动清理暂时不用的数据就使用WeakHashMap类。这样，当进行垃圾收集时会释放掉集合中的垃圾信息。

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;			//声明Map对象
		map = new WeakHashMap<String,String>();		//实例化Map对象
		map.put(new String("B"), new String("www.baidu.com"));	//增加内容
		map.put("A", "www.alibaba.com");			//增加内容
		System.gc();
		map.put("C", "www.google.com");	　　　　　　　　//增加内容
		System.out.println("内容："+map);
	}	

}

 

 

 

Map输出方式一：Iterator输出Map（使用 allSet = map.entrySet();，重要：开发中经常使用）

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;			//声明Map对象
		map = new WeakHashMap<String,String>();		//实例化Map对象
		map.put("B", "www.baidu.com");			//增加内容
		map.put("A", "www.alibaba.com");		//增加内容
		map.put("C", "www.google.com");			//增加内容
		Set<Map.Entry<String, String>> allSet = null;	//声明一个Set集合，指定泛型
		allSet = map.entrySet();					//将Map接口实例变为Set接口实例
		Iterator<Map.Entry<String, String>> iter = null;		//声明Iterator对象
		iter = allSet.iterator();					//实例化Iterator对象
		while(iter.hasNext()){
		　　Map.Entry<String, String> me = iter.next();			//找到Map.Entry实例
		　　System.out.println(me.getKey()+"-->"+me.getValue());
	}
	}	

}

 

Map输出方式二：foreach输出Map

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,String> map = null;			//声明Map对象
		map = new WeakHashMap<String,String>();		//实例化Map对象
		map.put("B", "www.baidu.com");			//增加内容
		map.put("A", "www.alibaba.com");		//增加内容
		map.put("C", "www.google.com");			//增加内容
		
		for(Map.Entry<String, String> me: map.entrySet()){
			System.out.println(me.getKey()+"-->"+me.getValue());
		}
		
	}	

}

 

直接使用非系统类作为Key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<String,person> map = null;				//声明Map对象，指定泛型类型
		map = new HashMap<String,person>();			//实例化Map对象
		map.put("zhangsan", new person("张三",30));
		System.out.println(map.get("zhangsan"));
	}	

}

 

 

key可以重复的Map集合：IdentityHashMap

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
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;

public class Map_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Map<person,String> map = null;				//声明Map对象，指定泛型类型
		map = new IdentityHashMap<person,String>();		//实例化Map对象
		map.put(new person("张三",30),"zhangsan_1");
		map.put(new person("张三",30),"zhangsan_1");
		
		Set<Map.Entry<person, String>> allSet = null;
		allSet = map.entrySet();
		Iterator<Map.Entry<person, String>> iter = null;
		iter = allSet.iterator();
		while(iter.hasNext()){
		　　Map.Entry<person, String> me = iter.next();		//找到Map.Entry实例
		　　System.out.println(me.getKey()+"-->"+me.getValue());
		}
	}	

}

 

SortedMap接口是排序接口，只要是实现了此接口的子类，都属于排序的子类，TreeMap也是此接口的一个子类。

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
34
35
36
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

public class SortedMap_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		SortedMap<String,String> map = null;				//声明Map对象
		map = new TreeMap<String,String>();	//key和value是String类
		map.put("zhangsan", "www.baidu.com");	//增加内容
		map.put("lisi", "www.alibaba.com");			//增加内容
		map.put("wangwu", "www.google.com");	//增加内容
		System.out.println("第一个元素的内容的key:"+map.firstKey());
		System.out.println("对应的值:"+map.get(map.firstKey()));
		System.out.println("最后一个元素的内容的key:"+map.lastKey());
		System.out.println("对应的值:"+map.get(map.lastKey()));
		
		System.out.println("输出小于指定范围的");
		for(Map.Entry<String, String> me: map.headMap("wangwu").entrySet()){
		System.out.println(me.getKey()+"-->"+me.getValue());
		}
		
		System.out.println("输出大于等于指定范围的");
		for(Map.Entry<String, String> me: map.tailMap("wangwu").entrySet()){
		System.out.println(me.getKey()+"-->"+me.getValue());
		}
		
		System.out.println("输出在指定范围的");
		for(Map.Entry<String, String> me: map.subMap("lisi","zhangsan").entrySet()){
		System.out.println(me.getKey()+"-->"+me.getValue());
		}
	}

}

19.输入数据类#

1.Scanner类#

专门的输入数据类，可以完成输入数据操作，也可以方便地对输入数据进行验证。

此类存放在java.util包中

<1>实例操作一：实现基本的数据输入#

使用Scanner类的next()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.Scanner;

public class Scanner_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner scan = new Scanner(System.in); 
		scan.useDelimiter("\n");			//修改输入数据的分隔符，不然空格以后的字符串不能显示，\n回车
		System.out.println("输入数据：");
		String str = scan.next();
		System.out.println("输入数据的数据为："+str);
	}

}

如果输入int或者是float类型的数据，scanner类中也支持，不过最好先使用hasNextXxx()方法进行验证

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
import java.util.Scanner;

public class Scanner_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		Scanner scan = new Scanner(System.in); 	//从键盘接收数据
		int i =0;
		float f = 0.0f;
		System.out.println("输入整数：");
		if(scan.hasNextInt()){
			i = scan.nextInt();
			System.out.println("输入的整数"+i);
		}else{
			System.out.println("输入的不是整数");
		}
		
		System.out.println("输入小数：");
		if(scan.hasNextFloat()){
			f = scan.nextFloat();
			System.out.println("输入的小数"+f);
		}else{
			System.out.println("输入的不是小数");
		}
	}

}

<2>实例操作一：实现日期格式的数据输入#

使用hasNext()对输入的数据进行正则验证，如果合法，则转换成Date类型

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Scanner_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Scanner scan = new Scanner(System.in); 
//		scan.useDelimiter("\n");			//修改输入数据的分隔符，不然空格以后的字符串不能显示，\n回车
//		System.out.println("输入数据：");
//		String str = scan.next();
//		System.out.println("输入数据的数据为："+str);
		
//		Scanner scan = new Scanner(System.in); 	//从键盘接收数据
//		int i =0;
//		float f = 0.0f;
//		System.out.println("输入整数：");
//		if(scan.hasNextInt()){
//			i = scan.nextInt();
//			System.out.println("输入的整数"+i);
//		}else{
//			System.out.println("输入的不是整数");
//		}
//		
//		System.out.println("输入小数：");
//		if(scan.hasNextFloat()){
//			f = scan.nextFloat();
//			System.out.println("输入的小数"+f);
//		}else{
//			System.out.println("输入的不是小数");
//		}
		
		Scanner scan = new Scanner(System.in); 	//从键盘接收数据
		System.out.println("输入日期(yyyy-MM-dd):");
		String str = null;
		Date date = null;
		if(scan.hasNext("^\\d{4}-\\d{2}-\\d{2}$")){		//判断输入格式是否是日期
			str = scan.next("^\\d{4}-\\d{2}-\\d{2}$");		//接收日期格式的字符串
			try{
				date = new SimpleDateFormat("yyyy-MM-dd").parse(str);
			}catch(ParseException e){
				e.printStackTrace();
			}
		}else{
			System.out.println("输入的日期格式错误");
		}
		System.out.println(date);
	}

}

<3>实例操作三：从文件中得到数据#

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.io.File;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Scanner_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Scanner scan = new Scanner(System.in); 
//		scan.useDelimiter("\n");			//修改输入数据的分隔符，不然空格以后的字符串不能显示，\n回车
//		System.out.println("输入数据：");
//		String str = scan.next();
//		System.out.println("输入数据的数据为："+str);
		
//		Scanner scan = new Scanner(System.in); 	//从键盘接收数据
//		int i =0;
//		float f = 0.0f;
//		System.out.println("输入整数：");
//		if(scan.hasNextInt()){
//			i = scan.nextInt();
//			System.out.println("输入的整数"+i);
//		}else{
//			System.out.println("输入的不是整数");
//		}
//		
//		System.out.println("输入小数：");
//		if(scan.hasNextFloat()){
//			f = scan.nextFloat();
//			System.out.println("输入的小数"+f);
//		}else{
//			System.out.println("输入的不是小数");
//		}
		
//		Scanner scan = new Scanner(System.in); 	//从键盘接收数据
//		System.out.println("输入日期(yyyy-MM-dd):");
//		String str = null;
//		Date date = null;
//		if(scan.hasNext("^\\d{4}-\\d{2}-\\d{2}$")){		//判断输入格式是否是日期
//			str = scan.next("^\\d{4}-\\d{2}-\\d{2}$");		//接收日期格式的字符串
//			try{
//				date = new SimpleDateFormat("yyyy-MM-dd").parse(str);
//			}catch(ParseException e){
//				e.printStackTrace();
//			}
//		}else{
//			System.out.println("输入的日期格式错误");
//		}
//		System.out.println(date);
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		Scanner scan = null;
		try{
			scan = new Scanner(f);					//从文件接收数据
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}
		StringBuffer str = new StringBuffer();		//用于接收数据
		while(scan.hasNext()){								//判断是否还有内容
			str.append(scan.next()).append("\n");	//分隔符分隔字符串，在每个字符串之后加上回车
		}
		System.out.println(str);
	}

}

2.BufferedReader类#

BufferedReader类用于从缓冲区中读取内容，多有的输入字节数据都将放在缓冲区中。

BufferedReader中定义的构造方法只能接收字符输入流的实例，所以必须使用字符输入流和字节输入流的转换类InputStreamReader将字节输入流System.in变为字符流

以下程序没有长度的限制，也可以正确地接收中文，所以以下代码就是键盘输入数据的标准格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferedReader_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		BufferedReader buf = null;				//声明BufferedReader对象
		buf = new BufferedReader(new InputStreamReader(System.in));	//实例化BufferedReader对象
		String str = null;								//接收输入内容
		System.out.print("请输入内容：");
		try{
			str = buf.readLine();						//读取输入内容
		}catch(IOException e){						//要进行异常处理
			e.printStackTrace();
		}
		System.out.println("输入的内容："+str);
	}
}

实例操作一：加法操作#

输入两个数字，并让两个数字相加

可以实现整数、小数、字符串和日期类型数据的输入

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

class InputData{
	private BufferedReader buf = null;			//声明BufferReader对象

	public InputData() {		//构造方法
		this.buf = new BufferedReader(new InputStreamReader(System.in));	//实例化BufferedReader对象
	}
	
	public String getString(String info){		//从此方法中得到字符串的信息
		String temp = null;								//接收输入内容
		System.out.println(info);
		 try{
			 temp = this.buf.readLine();                     //读取输入内容
	        }catch(IOException e){                      		//要进行异常处理
	            e.printStackTrace();
	        }
		return temp;
	}
	
	public int getInt(String info,String err){		//得到一个整数的输入数据
		int temp = 0;
		String str = null;
		boolean flag = true;									//定义一个循环的处理标志
		while(flag){
			str = this.getString(info);
			if(str.matches("^\\d+$")){							//符合数字的格式
				temp = Integer.parseInt(str);
				flag = false;
			}else{
				System.out.println(err);
			}
		}
		return temp;
	}
	
	public Float getFloat(String info,String err){		//得到一个小数的输入数据
		Float temp = 0f;
		String str = null;
		boolean flag = true;									//定义一个循环的处理标志
		while(flag){
			str = this.getString(info);
			if(str.matches("^\\d+.?\\d+$")){							//符合小数的格式
				temp = Float.parseFloat(str);
				flag = false;
			}else{
				System.out.println(err);
			}
		}
		return temp;
	}
	
	public Date getDate(String info,String err){		//得到一个日期的输入数据
		Date d = null;
		String str = null;
		boolean flag = true;									//定义一个循环的处理标志
		while(flag){
			str = this.getString(info);
			if(str.matches("^\\d{4}+\\d{2}$")){							//符合小数的格式
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				try{
					d = sdf.parse(str);				//将字符串变为Date型数据
				}catch(ParseException e){
					e.printStackTrace();
				}
				flag = false;							//更改标志位后，将退出循环
			}else{
				System.out.println(err);
			}
		}
		return d;
	}
}

public class BufferedReader_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int i;
		int j;
		InputData input = new InputData();
		i = input.getInt("请输入第一个数字：", "输入的数据必须是数字，请重新输入！");
		j = input.getInt("请输入第二个数字：", "输入的数据必须是数字，请重新输入！");
		System.out.println(i+"+"+j+"="+(i+j));
	}
}

实例操作二：菜单显示#

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class Operation{
	public static void add(){
		System.out.println("你选择的是增加操作！");
	}
	public static void delete(){
		System.out.println("你选择的是删除操作！");
	}
	public static void update(){
		System.out.println("你选择的是更新操作！");
	}
	public static void find(){
		System.out.println("你选择的是查看操作！");
	}
}

//主类
//Function        : 	menu_demo;
public class menu_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		while(true){
			show();
		}
	}
	
	public static void show(){
		System.out.println("菜单系统");
		System.out.println("【1】增加数据");
		System.out.println("【2】删除数据");
		System.out.println("【3】修改数据");
		System.out.println("【4】查看数据");
		System.out.println("【0】系统退出");
		InputData input = new InputData();
		int i = input.getInt("请选择", "请输入正确的选项");
		switch(i){
			case 1:{
				Operation.add();
				break;
			}
			case 2:{
				Operation.delete();
				break;
			}
			case 3:{
				Operation.update();
				break;
			}
			case 4:{
				Operation.find();
				break;
			}
			case 0:{
				System.exit(1);
				break;
			}
			default:{
				System.out.println("请选择正确的操作");
			}
		}
	}
}

20.File类#

使用File类可以进行创建或者删除文件等常用操作。

<1>创建一个新文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.File;
import java.io.IOException;

public class File_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		System.out.println("pathSeparator:"+File.pathSeparator);		//调用静态常量
		System.out.println("separator:"+File.separator);							//调用静态常量
		try{
			f.createNewFile();
		}catch(IOException e){
			e.printStackTrace();
		}
	}

}

 

 

<2>删除一个指定的文件

 使用File类中的delete()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.io.File;
import java.io.IOException;

public class delete_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		if(f.exists()){
			f.delete();
		}else{
			try{
				f.createNewFile();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}

}

 

<3>创建一个文件夹

使用mkdir()方法完成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.File;
import java.io.IOException;

public class delete_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		if(f.exists()){
			f.delete();
		}else{
			try{
				f.createNewFile();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		File f1 = new File("/home/common/software/coding/HelloWord/HelloWord/test");//路径
		f1.mkdirs();
	}

}

 

<4>列出指定目录的全部文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.io.File;
import java.io.IOException;

public class listFile_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord");//路径
//		String str[] = f.list();						//列出给定目录中的内容
		File files[] = f.listFiles();						//列出给定目录中的文件，包括路径
		for(int i = 0;i<files.length;i++){
			System.out.println(files[i]);
		}
	}
}

 

<5>判断一个给定的路径是否是目录

使用isDirectory()方法判断给定的路径是否是目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.io.File;
import java.io.IOException;

public class listFile_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord");//路径
		
		if(f.isDirectory()){
			System.out.println("是路径");
		}
	}
}

 

**<6>**列出指定目录的全部内容

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
import java.io.File;
import java.io.IOException;

public class File_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		File f = new File("/home/common/software/coding/HelloWord/HelloWord");//路径
		print(f);
	}
	
	public static void print(File file){
		if(file != null){
			if(file.isDirectory()){							//判断是否是目录
				File f[] = file.listFiles();					//如果是目录，则列出全部的内容
				if(f != null){										
					for(int i=0;i<f.length;i++){		//列出目录下的全部内容
						print(f[i]);
					}
				}
			}else{
				System.out.println(file);				//如果不是目录，则直接打印路径信息
			}
		}
	}
}

 

File类只是针对文件本身进行操作，而如果要对文件内容进行操作，则可以使用RandomAccessFile类，此类属于随机读取类，可以随机地读取一个文件中指定位置的数据。

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
import java.io.File;
import java.io.RandomAccessFile;

public class RandomAccessFile_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		RandomAccessFile rdf = null;				//声明一个RandomAccessFile类对象
		rdf = new RandomAccessFile(f,"r");	//以读写方式打开文件，会自动创建新文件
		
		String name = "zhangsan";
		int age = 30;
		
		rdf.writeBytes(name);
		rdf.writeInt(age);
		
		name = "lisi";
		age = 22;
		
		rdf.writeBytes(name);
		rdf.writeInt(age);
		
		name = "wangwu";
		age = 32;
		
		rdf.writeBytes(name);
		rdf.writeInt(age);
		rdf.close();
	}
}

21.日期操作类#

主要使用java.util包中的Date、Calendar以及java.text包中的SimpleDateFormat

1.Date类#

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Date;

public class Date_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Date date = new Date();										//实例化Date类对象
		System.out.println("当前日期为："+date);		//输出日期
	}

}

2.Calendar类#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Calendar_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Calendar calendar = null;							//声明一个Calendar对象
		calendar = new GregorianCalendar();		//通过子类为其实例化
		System.out.println("年："+calendar.get(Calendar.YEAR));
		System.out.println("月："+(calendar.get(Calendar.MONTH)+1));
		System.out.println("日："+calendar.get(Calendar.DAY_OF_MONTH));
		System.out.println("时："+calendar.get(Calendar.HOUR_OF_DAY));
		System.out.println("分："+calendar.get(Calendar.MINUTE));
		System.out.println("秒："+calendar.get(Calendar.SECOND));
		System.out.println("毫秒："+calendar.get(Calendar.MILLISECOND));
	}

}

输出

1
2
3
4
5
6
7
8
年：2017
月：5
日：17
时：20
分：56
秒：8
毫秒：427

 

DateFormat类

对java.util.Date进行格式化操作，为了符合中国人的习惯

DateFormat类和MessageFormat类都属于Format类的子类，专门用于格式化数据使用

DateFormat类是一个抽象类，无法直接实例化，但是在此抽象类中提供了一个静态方法，可以直接取得本类的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Date;
import java.text.DateFormat;

public class DateFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DateFormat df1 = null;										//声明DateFormat类对象
		DateFormat df2 = null;										//声明DateFormat类对象
		df1 = DateFormat.getDateInstance();				//取得日期
		df2 = DateFormat.getDateTimeInstance();		//取得日期时间
		System.out.println("DATE:"+df1.format(new Date()));		//格式化日期
		System.out.println("DATETIME:"+df2.format(new Date()));
	}

}
&nbsp;

 

指定显示的风格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Date;
import java.util.Locale;
import java.text.DateFormat;

public class DateFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DateFormat df1 = null;										//声明DateFormat类对象
		DateFormat df2 = null;										//声明DateFormat类对象

		
		//取得日期时间，设置日期的显示格式、时间的显示格式
		df1 = DateFormat.getDateInstance(DateFormat.YEAR_FIELD,new Locale("zh","CN"));
		df2 = DateFormat.getDateTimeInstance(DateFormat.YEAR_FIELD,DateFormat.ERA_FIELD,new Locale("zh","CN"));
		System.out.println("DATE:"+df1.format(new Date()));		//格式化日期
		System.out.println("DATETIME:"+df2.format(new Date()));
	}

}

输出

1
2
3
DATE:2017年5月17日
DATETIME:2017年5月17日 下午09时38分22秒 CST

 

格式化日期操作

首先使用第1个模板将字符串中表示的日期数字取出，然后再使用第2个模板将这些日期数字重新转化为新的格式表示。

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
34
35
36
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class DateFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		DateFormat df1 = null;										//声明DateFormat类对象
//		DateFormat df2 = null;										//声明DateFormat类对象
////		df1 = DateFormat.getDateInstance();				//取得日期
////		df2 = DateFormat.getDateTimeInstance();		//取得日期时间
//		
//		//取得日期时间，设置日期的显示格式、时间的显示格式
//		df1 = DateFormat.getDateInstance(DateFormat.YEAR_FIELD,new Locale("zh","CN"));
//		df2 = DateFormat.getDateTimeInstance(DateFormat.YEAR_FIELD,DateFormat.ERA_FIELD,new Locale("zh","CN"));
//		System.out.println("DATE:"+df1.format(new Date()));		//格式化日期
//		System.out.println("DATETIME:"+df2.format(new Date()));
		
		String strDate = "2016-3-11 10:20:30.123";		//定义日期时间的字符串
		String pat1 = "yyyy-MM-dd HH:mm:ss.SSS";		//准备第1个模板，从字符串中提取数字
		String pat2 = "yyyy年MM月dd日HH时mm分ss秒SSS毫秒";		//准备第1个模板，从字符串中提取数字
		SimpleDateFormat sdf1 = new SimpleDateFormat(pat1);			//实例化模板对象
		SimpleDateFormat sdf2 = new SimpleDateFormat(pat2);			//实例化模板对象
		
		Date d = null;
		try{
			d = sdf1.parse(strDate);				//将给定字符串中的日期提取出来
		}catch(ParseException e){				//如果提供的字符串格式有错误，则进行异常处理
			e.printStackTrace();
		}
		System.out.println(sdf2.format(d));				//将日期变成新的格式
	}

}

 输出

1
2
2016年03月11日10时20分30秒123毫秒

SimpleDateFormat的parse方法

1
2
3
4
5
6
7
8
public static void main(String[] args) throws ParseException {
	// TODO 自动生成的方法存根
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	String dateString = "2017-08-01";
	Date date = sdf.parse(dateString);
	System.out.println(date);
}

 输出

1
2
Tue Aug 01 00:00:00 CST 2017

 

实现：基于Calendar类

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
import java.sql.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;

class DateTime {
	private Calendar calendar = null;		//定义一个Calendar对象，可以取得时间

	public DateTime() {									
		super();
		this.calendar = new GregorianCalendar();		//通过Calendar类的子类实例化
	}
	
	public String getDate(){		//得到完整的日期，格式为：yyyy-MM-dd HH:mm:ss.SSS
		//考虑到程序要频繁修改字符串，所以使用StringBuffer提升性能
		StringBuffer buf = new StringBuffer();
		//依次取得时间
		buf.append(calendar.get(Calendar.YEAR)).append("-");
		buf.append(this.addZero(calendar.get(Calendar.MONTH)+1, 2));
		buf.append("-");
		buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH), 2));
		buf.append(" ");
		buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY), 2));
		buf.append(":");
		buf.append(this.addZero(calendar.get(Calendar.MINUTE), 2));
		buf.append(":");
		buf.append(this.addZero(calendar.get(Calendar.SECOND), 2));
		buf.append(".");
		buf.append(this.addZero(calendar.get(Calendar.MILLISECOND), 3));
		
		return buf.toString();
		
	}
	
	public String getDateComplete(){		//得到完整的日期，格式为：yyyy年MM月dd日HH时mm分ss秒SSS毫秒
		//考虑到程序要频繁修改字符串，所以使用StringBuffer提升性能
		StringBuffer buf = new StringBuffer();
		//依次取得时间
		buf.append(calendar.get(Calendar.YEAR)).append("年");
		buf.append(this.addZero(calendar.get(Calendar.MONTH)+1, 2));
		buf.append("月");
		buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH), 2));
		buf.append("日");
		buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY), 2));
		buf.append("时");
		buf.append(this.addZero(calendar.get(Calendar.MINUTE), 2));
		buf.append("分");
		buf.append(this.addZero(calendar.get(Calendar.SECOND), 2));
		buf.append("秒");
		buf.append(this.addZero(calendar.get(Calendar.MILLISECOND), 3));
		buf.append("毫秒");
		
		return buf.toString();
		
	}
	
	//考虑到日期中有前导0，所以在此处加上了补零的方法
	private String addZero(int num,int len){
		StringBuffer s = new StringBuffer(); 
		s.append(num);
		while(s.length()<len){		//如果长度不足，则继续补零
			s.insert(0,"0");					//在第1个位置处补零
		}
		return s.toString();
	}
	
	public String getTimeStamp(){		//得到时间戳：yyyyMMddHHmmssSSS
		StringBuffer buf = new StringBuffer();
		buf.append(calendar.get(Calendar.YEAR));
		buf.append(this.addZero(calendar.get(Calendar.MONTH)+1, 2));
		buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH), 2));
		buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY), 2));
		buf.append(this.addZero(calendar.get(Calendar.MINUTE), 2));
		buf.append(this.addZero(calendar.get(Calendar.SECOND), 2));
		buf.append(this.addZero(calendar.get(Calendar.MILLISECOND), 3));
		
		return buf.toString();
		
	}
	
}

public class CalendarClass_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DateTime dt = new DateTime();			//实例化DateTime对象
		System.out.println("系统时间："+dt.getDate());
		System.out.println("中文时间："+dt.getDateComplete());
		System.out.println("系统时间："+dt.getTimeStamp());
	}

}

 输出

1
2
3
4
系统时间：2017-05-17 20:41:06.508
中文时间：2017年05月17日20时41分06秒508毫秒
系统时间：20170517204106508

 

实现：基于SimpleDateFormat类

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
34
35
36
import java.util.Date;
import java.text.SimpleDateFormat;

class DateTime_1 {
	private SimpleDateFormat sdf = null;		//声明日期格式化操作对象，直接对new Date()进行实例化
	
	//得到日期，格式为：yyyy-MM-dd HH:mm:ss.SSS
	public String getDate(){		
		this.sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		return this.sdf.format(new Date());		
	}
	
	//得到完整的日期，格式为：yyyy年MM月dd日HH时mm分ss秒SSS毫秒
	public String getDateComplete(){		
		this.sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒");
		return this.sdf.format(new Date());		
	}
	
	//得到时间戳，格式为：yyyyMMddHHmmssSSS
	public String getDateStamp(){		
		this.sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		return this.sdf.format(new Date());		
	}
}

public class SimpleDateFormat_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		DateTime dt = new DateTime();			//实例化DateTime对象
		System.out.println("系统时间："+dt.getDate());
		System.out.println("中文时间："+dt.getDateComplete());
		System.out.println("系统时间："+dt.getTimeStamp());
	}
}

 输出

1
2
3
4
系统时间：2017-05-17 20:59:26.224
中文时间：2017年05月17日20时59分26秒224毫秒
系统时间：20170517205926224

22.Properties属性类#

在一个属性文件中保存了多个属性，每一个属性就是直接用字符串表示出来的”key=value对”，而如果想要轻松地操作这些属性文件中的属性，可以通过Properties类方便地完成。

 

<1>设置和取得属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Properties;

public class Properties_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Properties pro = new Properties();
		pro.setProperty("BJ", "Beijing");
		pro.setProperty("NJ", "Nanjing");
		pro.setProperty("TJ", "Tianjin");
		System.out.println("获得属性"+pro.getProperty("BJ"));
		System.out.println("获得属性不存在"+pro.getProperty("HB"));
		System.out.println("获得属性不存在，同时设置默认的显示值"+pro.getProperty("HB","：：：没有发现"));
	}
}

 

<2>将属性保存在普通文件中

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
import java.io.File;
import java.io.FileOutputStream;
import java.util.Properties;

public class Properties_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Properties pro = new Properties();
		pro.setProperty("BJ", "Beijing");
		pro.setProperty("NJ", "Nanjing");
		pro.setProperty("TJ", "Tianjin");
		System.out.println("获得属性"+pro.getProperty("BJ"));
		System.out.println("获得属性不存在"+pro.getProperty("HB"));
		System.out.println("获得属性不存在，同时设置默认的显示值"+pro.getProperty("HB","：：：没有发现"));
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.properties");//路径
		try{
			pro.store(new FileOutputStream(f),"pro info");		//保存并添加注释信息
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

 

<3>从普通文件中读取属性内容

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
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class Properties_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Properties pro = new Properties();
		pro.setProperty("BJ", "Beijing");
		pro.setProperty("NJ", "Nanjing");
		pro.setProperty("TJ", "Tianjin");
		System.out.println("获得属性"+pro.getProperty("BJ"));
		System.out.println("获得属性不存在"+pro.getProperty("HB"));
		System.out.println("获得属性不存在，同时设置默认的显示值"+pro.getProperty("HB","：：：没有发现"));
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.properties");//路径
		try{
			pro.load(new FileInputStream(f));		//读取属性文件
		}catch(Exception e){
			e.printStackTrace();
		}
		System.out.println("BJ属性值为"+pro.getProperty("BJ"));	
	}
}

 

<4>将属性保存在XML文件中

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
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class Properties_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Properties pro = new Properties();
		pro.setProperty("BJ", "Beijing");
		pro.setProperty("NJ", "Nanjing");
		pro.setProperty("TJ", "Tianjin");
		System.out.println("获得属性"+pro.getProperty("BJ"));
		System.out.println("获得属性不存在"+pro.getProperty("HB"));
		System.out.println("获得属性不存在，同时设置默认的显示值"+pro.getProperty("HB","：：：没有发现"));
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.xml");//路径
		try{
			pro.storeToXML(new FileOutputStream(f),"pro info");		//保存并添加注释信息
		}catch(Exception e){
			e.printStackTrace();
		}
		System.out.println("BJ属性值为"+pro.getProperty("BJ"));	
	}
}

 

<5>从XML文件中读取属性

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
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class Properties_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Properties pro = new Properties();
		pro.setProperty("BJ", "Beijing");
		pro.setProperty("NJ", "Nanjing");
		pro.setProperty("TJ", "Tianjin");
		System.out.println("获得属性"+pro.getProperty("BJ"));
		System.out.println("获得属性不存在"+pro.getProperty("HB"));
		System.out.println("获得属性不存在，同时设置默认的显示值"+pro.getProperty("HB","：：：没有发现"));
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.xml");//路径
		try{
			pro.loadFromXML(new FileInputStream(f));		//读取属性文件
		}catch(Exception e){
			e.printStackTrace();
		}
		System.out.println("BJ属性值为"+pro.getProperty("BJ"));	
	}
}

23.runtime类#

Runtime类表示运行时的操作类，是一个封装了JVM进程的类，每一个JVM都对应着一个Runtime类的实例，此实例由JVM运行时为其实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Runtime_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Runtime run = Runtime.getRuntime();
		
		System.out.println("JVM最大内存："+run.maxMemory());
		System.out.println("JVM空闲内存量："+run.freeMemory());
		String str = "HELLO";
		for (int i=0;i<1000;i++){
			System.out.println(str += i);
		}
		System.out.println("JVM空闲内存量："+run.freeMemory());
		run.gc();					//进行垃圾收集，释放空间
		System.out.println("JVM空闲内存量："+run.freeMemory());
	}
}

 

Runtime类与Process类

可以直接使用Runtime类运行本机的可执行程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Runtime_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Runtime run = Runtime.getRuntime();
	
		try{
			run.exec("notepad.exe");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

 

可以通过控制Process进行系统的进程控制，如果想要让进程消失，则可以使用destroy()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Runtime_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Runtime run = Runtime.getRuntime();
	
		Process pro = null;		//声明一个Process对象，接收启动的进程
		
		try{
			pro = run.exec("notepad.exe");
		}catch(Exception e){
			e.printStackTrace();
		}
		try{
			Thread.sleep(5000);
		}catch(Exception e){
			e.printStackTrace();
		}
		pro.destroy();
	}
}

24.system类#

System类是一些与系统相关属性和方法的集合，而且System类中所有的属性都是静态的，要想引用这些属性和方法，直接使用System类调用即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class System_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		long startTime = System.currentTimeMillis();	//取得开始计算之前的时间
		
		int sum = 0;					//累加操作
		for(int i=0;i<300000000;i++){
			sum += i;
		}
		
		long endTime = System.currentTimeMillis();	//取得开始计算之后的时间
		System.out.println("计算所花费的时间："+(endTime-startTime)+"毫秒");
		
		System.getProperties().list(System.out);			//列出系统的全部属性
		
		System.out.println("系统版本为："+System.getProperty("os.name")+System.getProperty("os.version")+System.getProperty("os.arch"));
		System.out.println("系统用户为："+System.getProperty("user.name"));
		System.out.println("当前用户目录："+System.getProperty("user.home"));
		System.out.println("当前用户工作目录："+System.getProperty("user.dir"));
	}
}

 

垃圾对象的回收

System类中也有一个rc()方法，此方法也可以进行垃圾的收集，而且此方法实际上是对Runtime类中的gc()方法的封装，功能与其类似。

对一个对象进行回收，一个对象如果不再被任何栈内存所引用，那么此对象就可以被成为垃圾对象，等待被回收。实际上，等待的时间是不确定的，所以可以直接调用System.gc()方法进行垃圾的回收。

 

System类对IO的支持

 

<1>System.out

System.out是PrintStream的对象，在PrintStream中定义了一系列的print()和println()方法

 

<2>System.err

System.err表示的是错误信息输出，如果程序出现错误，则可以直接使用System.err进行输出

 

<2>System.in

System.in实际上是一个键盘的输入流，其本身是InputStream类型的对象，可以利用**System.in**完成从键盘读取数据的功能。

指定空间的大小会出现空间限制，不指定大小则会在输入中文的时候产生乱码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package System;

import java.io.InputStream;

public class Systemin_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		InputStream input = System.in;			//从键盘接收数据
		byte b[] = new byte[1024];					//开辟空间，接收数据
		System.out.println("请输入内容：");
		int len = input.read(b);							//接收数据
		System.out.println("输入的内容："+new String(b,0,len));
		input.close();
	}
}

 

输入/输出重定向

通过System类也可以改变System.in的输入流来源和System.out和System.err两个输出流的输出位置

25.Java字节流#

在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据时要使用输入流读取数据，而当程序需要将一些数据保存起来时，就要使用输出流。

在java.io包中流的操作主要有字节流、字符流两大类，两类都有输入和输出操作。

在字节流中输出数据主要使用OutStream类完成，输入使用的是InputStream类。

在字符流中输出主要使用Write类完成，输入主要是使用Reader类完成。

字节流：字节流主要操作byte类型数据，以byte数组为准

主要操作类是OutputStream类和InputStream类。

<1>字节输出流：OutputStream类#

 OutputStream是整个IO包中字节输出流的最大父类

 

向文件中写入字符串

文件不存在则会自动创建

直接将一个字符串变为byte数组，然后将byte数组直接写入到文件中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.File;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class OutputStream_demo {

	public static void main(String[] args) throws Exception {		//异常抛出，不处理
		// TODO 自动生成的方法存根
		//第一步，找到一个文件
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		//第二步，通过子类实例化父类对象
		OutputStream out = null;				//准备好一个输出的对象
		out = new FileOutputStream(f);		//通过对象多态性，进行实例化
		//第三步，进行写操作
		String str = "HelloWord";				//准备一个字符串
		byte b[] = str.getBytes();				//只能输出byte数组，所以将字符串变成byte数组
		
		out.write(b); 									//将内容输出，保存文件
		//第四步，关闭输出流
		out.close(); 									//关闭输出流
	}
}

 

追加新内容

可以通过FileOutputStream向文件中追加内容。

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
import java.io.File;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class OutputStream_demo {

	public static void main(String[] args) throws Exception {		//异常抛出，不处理
		// TODO 自动生成的方法存根
		//第一步，找到一个文件
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		//第二步，通过子类实例化父类对象
		OutputStream out = null;				//准备好一个输出的对象
//		out = new FileOutputStream(f);		//通过对象多态性，进行实例化
		out = new FileOutputStream(f,true);		//此处表示在文件末尾追加内容
		//第三步，进行写操作
		String str = "HelloWord";				//准备一个字符串
		byte b[] = str.getBytes();				//只能输出byte数组，所以将字符串变成byte数组
		
//		out.write(b); 									//将内容输出，保存文件
		
		for(int i=0;i<b.length;i++){
			out.write(b[i]);
		}
		//第四步，关闭输出流
		out.close(); 									//关闭输出流
	}
}

 

<2>字节输入流：InputStream类#

和OutputStream一样，InputStream也是抽象类，必须依靠子类

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
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class InputStream_demo {

	public static void main(String[] args) throws Exception {		//异常抛出，不处理
		// TODO 自动生成的方法存根
		//第一步，找到一个文件
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		//第二步，通过子类实例化父类对象
		InputStream input = null;				//准备好一个输出的对象
		input = new FileInputStream(f);		//通过对象多态性，进行实例化
		//第三步，进行读操作
//		byte b[] = new byte[1024];				//所有的内容读到此数组中
		byte b[] = new byte[(int)f.length()];				//所有的内容读到此数组中，数组大小由文件决定
//		input.read(b);										//把内容取出，内容读到byte数组中
		int len = input.read(b);						
		//第四步，关闭输入流
		input.close();
		
		System.out.println("读入数据的长度："+len);				//没有多余的空格产生
		System.out.println("内容为："+new String(b,0,len));//把byte数组变为字符串输出
//		System.out.println("内容为："+new String(b));//把byte数组变为字符串输出
	}
}

 

在IO包中，提供了两个与平台无关的数据操作流，分别是数据输出流(DataOuputStream)和数据输入流(DataInputStream).

1.写入数据

 

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
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class DataOutputStream_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根

		DataOutputStream dos = null;			//声明数据输出流对象
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
		dos = new DataOutputStream(new FileOutputStream(f));	//实例化数据输出流对象
		
		String names[] = {"衬衣","手套","围巾"};
		float prices[] = {98.3f,30.0f,50.5f};
		int nums[] = {3,2,1};
		for(int i=0;i<names.length;i++){	//循环写入
			dos.writeChars(names[i]);			//写入字符串
			dos.writeChar('\t'); 					//加入分隔符
			dos.writeFloat(prices[i]);			//写入字符串
			dos.writeChar('\t'); 					//加入分隔符
			dos.writeInt(nums[i]);					//写入字符串
			dos.writeChar('\t'); 					//加入分隔符
		}
		dos.close();
	}
}

 

2.读取数据

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
34
35
36
37
38
39
40
41
42
43
44
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class DataInputStream_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根

		DataInputStream dis = null;			//声明数据输出流对象
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
		dis = new DataInputStream(new FileInputStream(f));	//实例化数据输出流对象
		
		String name = null;
		float price = 0.0f;
		int num = 0;
		char temp[] = null;
		char c = 0;									//存放接收的字符
		int len = 0;									//接收的字符的个数
		try{
			while(true){
				temp = new char[200];
				len = 0;
				while((c=dis.readChar()) != '\t'){	//读取字符
					temp[len] = c;								//接收内容
					len++;											//读取长度加1
				}		
				name = new String(temp,0,len);	//将字符数组变成String
				price = dis.readFloat();					//读取float
				dis.readChar();								//读取\t
				num = dis.readInt();						//读取int
				dis.readChar();								//读取\n
				System.out.printf("名称：%s,名称：%5.2f,名称：%d\n",name,price,num);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
		dis.close();
	}
}

26.java字符流#

在程序中一个字符等于两个字节，Java提供了Reader和Writer两个专门操作字符流的类。

<1>字符输出流Writer#

也是一个抽象类

和OutputStream相比，可以直接输出字符串，而不用将字符串变为byte数组之后再输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.Writer;

public class Write_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		//第一步，找到一个文件
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		//第二步，通过子类实例化父类对象
		Writer out = null;				//准备好一个输出的对象
//		out = new FileWriter(f);		//通过对象多态性，进行实例化
		out = new FileWriter(f,true);		//通过对象多态性，进行实例化
		//第三步，进行写操作
		String str = "HelloWord!!!";				//准备一个字符串
		out.write(str);										//把内容取出，内容读到byte数组中
		//第四步，关闭输入流
		out.close();
	}
}

 

<2>字符输入流Reader#

Reader是使用字符的方式从文件中取出数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public class Reader_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		//第一步，找到一个文件
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		//第二步，通过子类实例化父类对象
		Reader reader = null;				//准备好一个输出的对象
		reader = new FileReader(f);		//通过对象多态性，进行实例化
		//第三步，进行读操作
		char c[] = new char[1024];		//所有的内容读到此数组中
		int len = reader.read(c);			//将内容输出
		//第四步，关闭输入流
		reader.close();							//关闭输入流
		System.out.println("内容为："+new String(c,0,len));		//把char数组变为字符串输出
	}

}

字节流与字符流的区别#

字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的

字符流在操作时使用了缓冲区，通过缓冲区再操作文件

如果一个程序频繁地操作一个资源（如文件或者数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。

使用字节流更好

27.java转换流：字节流和字符流的转换类#

InputStreamReader：是Reader的子类，将输入的字节流变成字符流#

将字节输出流变成字符输出流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutputStreamWriter_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		Writer out = null;
		out = new OutputStreamWriter(new FileOutputStream(f));	//字节流变成字符流
		out.write("HelloWord");
		out.close();
	}
}

 

OutputStreamWriter：是Writer的子类，将输出的字符流变成字节流#

将字节输出流变成字符输出流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class InputStreamReader_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		Reader reader = null;
		reader = new InputStreamReader(new FileInputStream(f));	//字节流变成字符流
		char c[] = new char[1024];
		int len = reader.read(c);
		reader.close();
		System.out.println(new String(c,0,len));
	}
}

28.管道流：主要作用是可以进行两个线程间的通信#

分为管道输出流(PipedOutputStream)和管道输入流(PipedInputStream)

定义两个线程对象,在发送的线程类中定义了管道输出类,在接收的线程类中定义了管道的输入类,在操作时只需要使用PipedOutputStream类中提供的connection()方法就可以将两个线程冠带连接在一起,线程启动后会自动进行管道的输入和输出操作

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

class Send implements Runnable{		//实现Runnable接口
	
	private PipedOutputStream pos = null;	//管道输出流
	
	public Send() {	//实例化输出流
		super();
		this.pos = new PipedOutputStream();
	}
	
	public PipedOutputStream getPos() {		//通过线程类得到输出流
		return pos;
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		String str = "HelloWord!!";
		try{
			this.pos.write(str.getBytes());		//输出信息
		}catch(IOException e){
			e.printStackTrace();
		}
		try{
			this.pos.close(); 							//关闭输出流
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

class Receive implements Runnable{		//实现Runnable接口
	
	private PipedInputStream pis = null;	//管道输入流
	
	public Receive() {	//实例化输出流
		super();
		this.pis = new PipedInputStream();
	}
	
	public PipedInputStream getPis() {		//通过线程类得到输入流
		return pis;
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		byte b[] = new byte[1024];	//实例化输入流
		int len = 0;
		try{
			len = this.pis.read(b);			//接收数据
		}catch(IOException e){
			e.printStackTrace();
		}
		try{
			this.pis.close(); 							//关闭输入流
		}catch(IOException e){
			e.printStackTrace();
		}
		System.out.println("接收的内容为"+new String(b,0,len));
	}
}

public class Pipe_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Send s = new Send();
		Receive r = new Receive();
		try{
			s.getPos().connect(r.getPis());  	//连接管道
		}catch(IOException e){
			e.printStackTrace();
		}
		new Thread(s).start();
		new Thread(r).start();
	}
}
&nbsp;

29.内存操作流：可以将输出的位置设置在内存上#

此时就要使用ByteArrayInputStream、ByteArrayOutputStream来完成输入和输出功能。

ByteArrayInputStream主要完成将内容写入到内存中

ByteArrayOutputStream的功能主要是将内存中的数据输出

 

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
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayStream_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String str = "HELLOWORD";
		ByteArrayInputStream bis = null;			//声明一个内存的输入流
		ByteArrayOutputStream bos = null;		//声明一个内存的输出流
		bis = new ByteArrayInputStream(str.getBytes());	//向内存中输入内容
		bos = new ByteArrayOutputStream();						//准备从ByteArrayInputStream中读数据
		
		int temp = 0;
		while((temp=bis.read()) != -1){
			char c = (char)temp;		//将读取的数字变为字符
			bos.write(Character.toLowerCase(c));		//将字符变为小写
		}
		String newStr  = bos.toString();					//取出内容
		try{
			bis.close();
			bos.close();
		}catch(IOException e){
			e.printStackTrace();
		}
		System.out.println(newStr);
	}
}
&nbsp;

30.压缩流#

ZIP是一种较为常见的压缩形式，在Java中要实现ZIP的压缩需要导入java.util.zip包，可以使用此包中的ZipFile、ZipOutputStream、ZipInputStream和ZipEntry几个类完成操作。

 

<1>ZipFile类#

压缩一个文件

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
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipOutputStream_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		File file = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
		File zipfile = new File("/home/common/software/coding/HelloWord/HelloWord/order.zip");//路径
		
		InputStream input = new FileInputStream(file);		//定义输入文件流
		ZipOutputStream zipout = null;									//定义压缩输出流
		//实例化压缩输出流对象，并指定压缩文件的输出路径
		zipout = new ZipOutputStream(new FileOutputStream(zipfile));
		//每一个被压缩的文件都用ZipEntry表示，需要为每一个压缩后的文件设置名称
		zipout.putNextEntry(new ZipEntry(file.getName()));		//创建ZipEntry
		zipout.setComment("这是压缩后的文件");						//设置注释
		int temp = 0;																		//接收输入的数据
		while((temp = input.read()) != -1){									//读取内容，采用了边读边写的方式
			zipout.write(temp);															//压缩输出内容
		}
		input.close();
		zipout.close();
	}
}

压缩一个文件夹

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipOutputStream_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
//		File file = new File("/home/common/software/coding/HelloWord/HelloWord/order.txt");//路径
//		File zipfile = new File("/home/common/software/coding/HelloWord/HelloWord/order.zip");//路径
//		
//		InputStream input = new FileInputStream(file);		//定义输入文件流
//		ZipOutputStream zipout = null;									//定义压缩输出流
//		//实例化压缩输出流对象，并指定压缩文件的输出路径
//		zipout = new ZipOutputStream(new FileOutputStream(zipfile));
//		//每一个被压缩的文件都用ZipEntry表示，需要为每一个压缩后的文件设置名称
//		zipout.putNextEntry(new ZipEntry(file.getName()));		//创建ZipEntry
//		zipout.setComment("这是压缩后的文件");						//设置注释
//		int temp = 0;																		//接收输入的数据
//		while((temp = input.read()) != -1){									//读取内容，采用了边读边写的方式
//			zipout.write(temp);															//压缩输出内容
//		}
//		input.close();
//		zipout.close();
		
		File file = new File("/home/common/software/coding/HelloWord/HelloWord/test");//路径
		File zipfile = new File("/home/common/software/coding/HelloWord/HelloWord/order.zip");//路径
		
		InputStream input = null;		//定义输入文件流
		ZipOutputStream zipout = null;									//定义压缩输出流
		//实例化压缩输出流对象，并指定压缩文件的输出路径
		zipout = new ZipOutputStream(new FileOutputStream(zipfile));
		zipout.setComment("这是压缩后的文件");						//设置注释
		if(file.isDirectory()){						//判断是否是目录
			File lists[] = file.listFiles();			//列出全部文件
			for(int i=0;i<lists.length;i++){
				input = new FileInputStream(lists[i]);		//设置文件输入流
				//每一个被压缩的文件都用ZipEntry表示，需要为每一个压缩后的文件设置名称
				zipout.putNextEntry(new ZipEntry(file.getName()+File.separator+lists[i].getName()));		//创建ZipEntry
				int temp = 0;
				while((temp = input.read()) != -1){
					zipout.write(temp);
				}
				input.close();
			}
		}
		zipout.close();
	}
}

 

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
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

public class ZipFile_demo {

	public static void main(String[] args)  throws Exception{
		// TODO 自动生成的方法存根
		File file = new File("/home/common/software/coding/HelloWord/HelloWord/b.zip");//路径
		File outputfile = new File("/home/common/software/coding/HelloWord/HelloWord/b1.txt");//解压缩文件名称
		
		ZipFile zipfile = new ZipFile(file);											//实例化ZipFile对象
//		System.out.println("压缩文件的名称："+zipfile.getName());	//得到压缩文件的名称
		ZipEntry entry = zipfile.getEntry("b2.txt");						//得到一个压缩实体
		InputStream input = zipfile.getInputStream(entry);			//取得ZipEntry输入流
		OutputStream out = new FileOutputStream(outputfile);			//取得ZipEntry输入流
		
		int temp = 0;				//保存接收数据
		while((temp = input.read()) != -1){
			out.write(temp);
		}
		input.close();
		out.close();
	}
}

 

<2>ZipInputStream类#

ZipInputStream是InputStream的子类，通过此类可以方便地读取ZIP格式的压缩文件

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
34
35
36
37
38
39
40
41
42
43
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

public class ZipInputStream_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		File file = new File("/home/common/software/coding/HelloWord/HelloWord/HelloWord.zip");//路径
		File outfile = null;				//定义输出的文件对象
		ZipFile zipfile = new ZipFile(file);	//实例化ZipFile对象
		ZipInputStream zipinput = new ZipInputStream(new FileInputStream(file)); 	//实例化ZIP输入流
		ZipEntry entry = null;						//定义一个ZipEntry对象，用于接收压缩文件中的每一个实体
		InputStream input = null;				//定义输入流，用于读取每一个ZipEntry
		OutputStream out = null;					//定义输出流，用于输出每一个实体内容
		while((entry = zipinput.getNextEntry()) != null){		//得到每一个ZipEntry
			System.out.println("解压缩"+entry.getName()+"文件");
			outfile = new File("/home/common/software/coding/HelloWord/HelloWord"+entry.getName());
			if(!outfile.getParentFile().exists()){		//判断文件夹是否存在
				outfile.getParentFile().mkdirs();
			}
			if(!outfile.exists()){				//判断文件是否存在
				outfile.createNewFile();
			}
			input = zipfile.getInputStream(entry);		//得到压缩实体的输入流
			out = new FileOutputStream(outfile);		//实例化输入流对象
			int temp = 0;
			while((temp = input.read()) != -1){
				out.write(temp);
			}
			input.close();
			out.close();
		}
	}
}

31.合并流：主要功能是将两个文件的内容合并成一个文件#

如果要实现合并流，则必须使用SequenceInputStream类

 

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
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;

public class SequenceInputStream_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		InputStream is1 = null;				//输入流1
		InputStream is2 = null;				//输入流2
		OutputStream os = null;				//输出流
		SequenceInputStream sis = null;	//合并流
		
		is1 = new FileInputStream("/home/common/software/coding/HelloWord/HelloWord/a.txt");
		is2 = new FileInputStream("/home/common/software/coding/HelloWord/HelloWord/b.txt");
		os = new FileOutputStream("/home/common/software/coding/HelloWord/HelloWord/ab.txt");
		sis = new SequenceInputStream(is1,is2);				//实例化合并流
		int temp = 0;
		while((temp = sis.read()) != -1){
			os.write(temp);
		}
		sis.close();
		is1.close();
		is2.close();
		os.close();
	}
}

32.对象序列化**
**#

对象序列化就是把一个对象变为二进制的数据流的一种方法。

通过对象序列化可以方便地实现对象的传输或存储。

如果一个类的对象想被序列化，则对象所在的类必须实现java.io.Serializable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Person_3 implements Serializable{		//此类的对象可以被序列化
	private String name;
	private int age;
	
	public Person_3(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + ", 年龄：" + age;
	}
}

 此类的对象是可以经过二进制数据流进行传输的

如果要完成对象的输入或者输出，还必须依靠对象输出流(ObjectOutputStream)和对象输入流(ObjectInputStream).

使用对象输出流输出序列化对象的步骤有时也称为序列化

而使用对象输入流读入对象的过程有时也称为反序列化

<1>对象输出流ObjectOutputStream#

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
34
35
36
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

class Person_3 implements Serializable{		//此类的对象可以被序列化
	private String name;
	private int age;
	
	public Person_3(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + ", 年龄：" + age;
	}
}

public class Serializable_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		ObjectOutputStream oos = null;
		OutputStream out = new FileOutputStream(f);		//文件输出流
		oos = new ObjectOutputStream(out);						//为对象输出流实例化
		oos.writeObject(new Person_3("张三", 30));
		oos.close();
	}

}

<2>对象输出流ObjectInputStream#

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
34
35
36
37
38
39
40
41
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

class Person_3 implements Serializable{		//此类的对象可以被序列化
	private String name;
	private int age;
	
	public Person_3(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + ", 年龄：" + age;
	}
}

public class Serializable_demo {

	public static void main(String[] args) throws Exception {
		// TODO 自动生成的方法存根
		
		File f = new File("/home/common/software/coding/HelloWord/HelloWord/test.txt");//路径
		ObjectInputStream ois = null;
		InputStream input = new FileInputStream(f);		//文件输入流
		ois = new ObjectInputStream(input);						//为对象输入流实例化
		Object obj = ois.readObject();									//读取对象
		ois.close();
		System.out.println(obj);
	}
}

33.Java国际化程序#

根据不同的国家配置不同的资源文件（资源文件有时也称为属性文件，后缀为.properties），所有的资源文件以键值对的形式出现。

 

Locale类

 

ResourceBundle类

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.ResourceBundle;;

public class Locale_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		ResourceBundle rb = ResourceBundle.getBundle("Message"); //找到资源文件
		System.out.println("内容："+rb.getString("info"));						//从资源文件中取得内容
	}

}

　　

根据Locale所选择的国家不同，输出不同国家的“你好”。

在属性文件中不能直接写入中文，读出来也是乱码，因此要变成Unicode编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Locale;
import java.util.ResourceBundle;

public class Locale_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		Locale zhLoc = new Locale("zh","CN");		//表示中国地区
		Locale enLoc = new Locale("en","US");		//表示美国地区
		Locale frLoc = new Locale("fr","FR");		//表示法国地区
		
		ResourceBundle zhrb = ResourceBundle.getBundle("Message", zhLoc);	//找到中文的属性文件
		ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc);	//找到英文的属性文件
		ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc);	//找到法语的属性文件
		
		System.out.println("中文："+zhrb.getString("info"));
		System.out.println("英文："+enrb.getString("info"));
		System.out.println("法语："+frrb.getString("info"));
	}

}

 

使用MessageFormat格式化动态文本

所有资源内容都是个固定的，但是输出的消息中如果包含一些动态文本，则必须使用占位符清楚地表示出动态文本的位置，占位符使用“{编号}”的格式出现。

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
34
import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;

public class Locale_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		ResourceBundle rb = ResourceBundle.getBundle("Message"); //找到资源文件
//		System.out.println("内容："+rb.getString("info"));						//从资源文件中取得内容
		
		Locale zhLoc = new Locale("zh","CN");		//表示中国地区
		Locale enLoc = new Locale("en","US");		//表示美国地区
		Locale frLoc = new Locale("fr","FR");		//表示法国地区
		
		ResourceBundle zhrb = ResourceBundle.getBundle("Message", zhLoc);	//找到中文的属性文件
		ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc);	//找到英文的属性文件
		ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc);	//找到法语的属性文件

		System.out.println("中文："+zhrb.getString("info"));
		System.out.println("英文："+enrb.getString("info"));
		System.out.println("法语："+frrb.getString("info"));
		
		//依次读取各个属性文件的内容，通过键值读取，此时的键值名称为&ldquo;info_1&rdquo;
		String str1 = zhrb.getString("info_1");
		String str2 = enrb.getString("info_1");
		String str3 = frrb.getString("info_1");
		System.out.println("中文："+MessageFormat.format(str1,"张三"));
		System.out.println("英文："+MessageFormat.format(str2,"zhangsan"));
		System.out.println("法语："+MessageFormat.format(str3,"zhangsan"));
	}

}

 properties文件，文件名Message_zh_CN.properties

1
2
3
info = \u4F60\u597D
info_1 = \u4F60\u597D\uFF0C{0}\uFF01

 

tonglin0325

标签

标签云

AWS Airbnb Android CDH Doris ELK Flink Git Grafana HAProxy HBase Hadoop Hive Hudi InfluxDB JDBC JMeter JVM JavaSE JavaWeb LaTex Linkedin Linux ML ML Infra MPP Maven MySQL Nexus OpenTSDB Paper Play Prometheus Python React Redis RocksDB Scala Solr Spark SpringBoot SpringMVC Thrift YARN antlr arthas avro cassandra clickhouse confluent docker filebeat flume golang google gradle hexo impala jenkins k8s kafka kerberos kudu ldap mac mongo mybatis nginx nlp open-falcon parquet presto ranger scyllaDB twitter zookeeper 前端 图存储及计算 多线程 广告系统 开发工具 数据结构 杂谈 正则表达式 算法 系统设计 计算机网络 设计模式

文章归档

最近文章