JavaSE学习笔记——1、Basic knowledge

1
2
3
int a;//定义一个变量
a = 2;//为变量赋值，右边赋值给左边
int a = 2;//等价上2行代码

1
2
3
4
5
6
7
//单行注释
/*
多行注释，源自C++
*/
/**
*文档注释，用于产生help documents
*/

1
2
3
4
//混合类型运算判断技巧：
int a = 3;
float b = 3.2f;
float c = a*b;//以等号为界，赋值前结果类型取决于参与运算的表示范围最大的variable type，赋值时遵循表示范围小可赋值给表示范围大的原则。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//三元表达式：
d==a?b:c//(d==a)为true返回b，为false返回c 
//判断
if(boolean expression)
{fragment code}
else
{fragment code}
//循环一
for(int i=0;i<10,i++)//当想以计数循环时（可预见的计数范围）
{fragment code}
//循环二
do//do程序块的代码至少会被执行一次
{fragment code}
while(boolean expression)//当仅想以某种状态运行至得到一种结果时
{fragment code
continue;//跳出本次loop，但不中止loop，继续下次loop，即continue可以实现当满足某种情况就跳过continue以下的代码
}
//选择
switch(variable){
case 1:……break;//break结束本次控制语句，不加则继续执行后续case&default
case 2:……break;
……
default:……break;
}

1
public abstract final class Test{……}//思考这样写对吗？

1
2
3
4
5
6
7
8
9
10
11
12
//Singleton Patterns（创建型模式分支）
//一个类只会生成唯一一个对象
public class Singleton{
private static Singleton instance = new Singleton();
private Singleton()
{
}
public static Singleton getInstance()
{
return instance;
}
}

1
import com.microsoft.xxx;//import为导入包关键字

1
2
3
4
5
6
7
8
System.out.println(Obj);
//等价于
System.out.println(Obj.toString());
//未被Override的toString()
public String toString()
{
return getClass().getName()+"@"+Integer.toHexString(hashCode());
}

1
2
3
4
5
6
7
8
9
10
String a = "hello";
String b = "hello";
String c = "hel";
String d = "lo";
String e = new String("hello");
String f = new String("hello);
a==b;//true
a==(c+d)//false
a==e//false
e==f//false

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
//String重写的equals方法
public boolean equals(Object anObject)
{
if(this == anObject)
{
return true;
}
if(anObject instanceof String)
{
String anotherString = (String)anObject;
int n = count;
if(n == anotherString.count)//判断两个字符串长度是否相等
{
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while(n--!=0)
{
if(v1[i++] != v2[i++])//逐个字符判断是否相等
return false;
}
return true;//全等返回true
}
}
return false;
}

1
2
String a = "test";//创建String实例a，赋值时，查找StringPool中是否存在“test”值，不存在则写入“test”并返回地址
String b = "test";//创建String实例b，赋值时，从StringPool中找到“test”值，返回地址

1
2
3
4
public boolean equals(Object obj)
{
return (this == obj);//对比两个对象的地址
}

1
2
3
a.intern() == b.intern();
等价于
a.equals(b);

1
2
3
4
StringBuffer sb = new StringBuffer();
sb.append("hello").append(" world");
sb = sb.append(" welcome");
//Result:hello world welcome

1
2
3
4
String a = "hel";
a += "lo";//String的实例a在追加字符串操作后hashcode会产生变化，即产生一个新对象
StringBuffer sb = new StringBuffer();
sb.append("hel").append("lo");//StringBuffer的实例sb在追加字符串操作后hashcode不会产生变化

1
2
3
4
int x = 5;//1
Integer y = new Integer(x);//2
int z = y.intValue();//3
//1到2的过程称为boxing，2到3的过程称为unboxing

1
2
3
4
5
6
int[] a = new int[10];/Java推荐使用这种形式
//等价于
int a[] = new int[10];
//初始化并赋值
int[] a = {1,2,3};
int[] a = new int[]{1,2,3};

1
int[][] a = new int[][]{{1,2},{3,4}};

1
2
3
4
int a = 4,b = 3;
a = a + b;
b = a - b;
a = a - b;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void swap(char[] ch,char c)
{
ch[0] = 'B';//数组作为实参传递的是引用（地址），所以赋值会改变其值
c = 'D';//primitive作为实参传递的是值（把值copy给形参），因此不会改变其值
}
public static void main(String[] args)
{
char[] ch = {'A','C'};
swap(ch,ch[1]);
for(int i = 0;i < ch.length;i++)
{
System.out.println(ch[i]);
}
}//Result:B
C

1
2
3
4
5
6
int[] a = {1,2,3};
int[] b = {1,2,3};
System.out.println(a.equals(b));//false
System.out.println(Arrays.equals(a,b));//true
int[] c = new int[3];
System.arrayCopy(a,0,c,0,3);//从a的第0个下标开始依次拷贝3个元素到c的第0个下标开始 

1
2
3
4
5
6
7
8
9
10
11
12
13
//BubbleSort core：
for(int i = 0;i < array.length-1;i++)
{
for(int j = 0;j < array.length-i-1;j++)
{
if(array[j] > array[j+1])
{
array[j] = array[j] - array[j+1];
array[j+1] = array[j] + array[j+1];
array[j] = array[j+1] - array[j];
}
}
}

1
2
3
4
5
6
//LinearSearch core：
for(int i = 0;i < array.length;i++)
{
if(key == array[i]
return i;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
//BinarySearch core：
int lh = 0;rh = array.length-1,middle;
while(lh <= rh)
{
middle = (lh+rh)/2;
if(array[middle] == key)
return middle+1;//返回位置
if(array[middle] > key)
rh = middle-1;
if(array[middle] < key)
lh = middle+1;
}
return -1;//没找到返回-1

1
2
3
4
5
6
7
8
double ceil = Math.ceil(16.34);//返回大于指定数的最小整数
double floor = Math.floor(12.34);//返回小于指定数的最大整数
long round = Math.round(12.54);//四舍五入
double pow = Math.pow(2,3);//幂运算，2的3次方
double random1 = Math.random();//伪随机数，大于等于0.0，小于1.0
int random2 = (int)(Math.random()*10 + 1);//随机输出1~10
Random r = new Random();//同为伪随机数
int random3 = r.nexInt(10);//无需强转，直接返回int随机数，括号内10为“乘10”

1
2
3
4
5
6
ArrayList<Integer> list = new ArrayList<Integer>();
int x = 5;
Integer y = new Integer(x);//int==>Integer is boxing
list.add(y);//ArrayList只接受Object，因此对于primitives需要wrap后，才能存入。
Integer z = (Integer)list.get(0);
int f = z.intValue();//Integer==>int is unboxing

1
2
3
4
5
6
7
8
9
10
11
12
MyComparator mc = new MyComparator();
TreeSet ts = new TreeSet(mc);//为TreeSet限定一套Sort规则，就能正常对Object进行比较了
//MyComparator实现Comparator接口，至少实现compare(T e1,T e2)方法
class MyComparator implements Comparator
{
public int compare(Object arg0,Object arg1)
{
String s1 = (String)arg0;
String s2 = (String)arg1;
return s2.compareTo(s2);//compareTo()以字典顺序对两个String进行比较
}
}

1
2
3
4
Comparator r = Collections.reverseOrder();//按自然顺序的反序进行排序
Collections.sort(list,r);//按指定规则“r”对集合“list”进行排序
Collection.shuffle(list);//将集合顺序打乱
Collection.min/max(list);//返回集合中最小/最大的数，该方法也有比较器形式min/max(list,comparator)

1
2
3
4
5
6
7
8
9
10
11
12
for(int i = 0;i < args.length;i++)
{
if(!map.containsKey(args[i]))
{
map.put(args[i],1);
}
else
{
int count = map.get(args[i]);
map.put(args[i],++count);
}
}

1
2
3
4
5
6
7
Set set = map.entrySet();
for(Iterator iter = set.iterator();iter.hashNext();)
{
Map.Entry entry = (Map.Entry)iter.next();
String key = (String)entry.getKey();
Strng value = (String)entry.getValue();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class GenericFoo<T>
{
private T foo;
public void setFoo(T foo)
{
this.foo = foo;
}
public T getFoo()
{
return foo;
}
}
GenericFoo foo = new GenericFoo();//“〈〉”中传入何种类型，该类中的泛型就会转化为该类型，泛型：即变量类型参数化

1
2
3
4
public class genericFoo<T extends List>{//泛型T必须是List接口层次体系下的一员}
GenericFoo<? extends List> foo = null;//?为通配符，声明了foo可以指向实现List接口的对象，进一步将强了Generic的灵活性
foo = new GenericFoo<ArrayList>();
foo = new GenericFoo<LinkedList>();

1
for(Type buf : src){//缺点：会丢失Array&Collection的subscript}

1
2
3
4
5
6
Map<String, Integer> map = new HashMap<String, Integer>();
for(String word : args)
{
map.put(word, (null == map.get(word)) ? 1 : map.get(word)+1);
}

1
2
3
4
5
6
7
8
9
10
public enum Coin
{
penny("PENNY"), nickel("NICKEL"), dime("DIME"),RMB{ public Coin nextCoin(){ return "人民币" } };//每个枚举成员都是一个对象（类似子类），可以在成员内定义方法，但不能是抽象方法
private String value;
public String getValue()
{
return value;
}
public abstract getCoin();
}

1
2
3
4
5
6
Class<?> clazz = AnClass.class;//通过Java内置对象
Class<?> clazz = Class.forName("com.relection.AnClass");
Object instance = clazz.newInstance();//创建该class对象所代表的类的实例
Mehotd method = clazz.getMehotd("methodName", new Class[]{int.class, int.class});//指定方法的pramType
Object result = method.invoke(instance, new Object[]{1, 3});//指定调用哪个实例的方法并传参给方法
System.out.println((Integer)result);

1
2
3
Class<?> clazz = obj.getClass();
COnstructor cons = clazz.getConstructor(new Class[]{String.class, int.class});
Object instance = cons.newInstance(new Object[]{"name", 25});

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
Field[] f = clazz.getDeclaredFields();
for(Field fbuf : f)
{
String name = fbuf.getName();//获得的方法名为全小写，所以要将其首字母转换为大写
String firstL = name.substring(0,1).toUpperCase();//截取方法名首字母并转换为大写
String getMN = "get" + firstL + name.substring(1);//拼接get方法
String setMn = "set" + firstL + name.substring(1);//拼接set方法
Method getM = clazz.getMethod(getMN, new Class[]{});//声明get方法实例
Method setM = clazz.getMethod(setMN, new Class[]{fbuf.getType()});//声明set方法实例
Object value = getM.invoke(obj, new Object[]{});//通过get方法实例调用方法，将返回值赋给value
setM.invoke(instance, new Object[]{ value});//通过set方法实例调用方法，把value当作实参传入
}
//用Reflection进行String对象中的字符替换
public static void compareTypeString(Object obj)
{
Field[] fields = obj.getClass().getFields();
for(Field field : fields)
{
if(field.getType() == String.class)
{
String buf = (String)field.get(obj);//从obj对象中取出field对应的值，downcast到String
String nbuf = buf.replace("b", "a");//将String中的b替换为a
field.set(obj, nbuf);//将obj对象中field对应的值设置为nbuf
}
}
}

1
2
3
4
5
6
7
8
9
10
11
ReflectPoint rp1 = new ReflectPoint(3,5);//该类有一个构造方法接收两个int赋给局部变量x、y，即x=3，y=5
String propertyName = "x";
//JavaBean的简单内省操作，get方法
PropertyDescript pd = new PropertyDescript(propertyName,rp1.class);//Java提供的PropertyDescript属性描述符
Method methodGetX = pd.getReadMethod();
Object retVal = methodGetX.invoke(rp1);
System.out.println(retVal)//result=3;
//JavaBean的简单内省操作，set方法
PropertyDescript pd2 = new PropertyDescript(propertyName,rp1.class);
Method methodSetX = pd2.getWriteMethod();
methodSetX.invoke(rp1,8);//关于set的invoke方法调用，它本身是接收一个对象类型的Integer，但由于jdk5开始具备auto boxing功能，所以会把int型的8自动转变为Integer的8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static Object getProperty(Object obj1, String propertyName)
{
BeanInfo beanInfo = Introspector.getBeanInfo(obj1.getClass());
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
Object retVal = null;
for(PropertyDescriptor pd : pds)
{
if(pd.getName().equals(propertyName))
{
Method methodGetX = pd.getReadMethod();
retVal = methodGetX.invoke(obj1);
break;
}
}
return retVal;
}

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)//元注解，Retention有三种等级：SOURCE、CLASS、RUNTIME
@Target(ElementType.CLASS)//也是元注解，表示注解可用于什么地方
public @interface AnnotationExample
{
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@AnnotationExample
public class AnnotationApplication
{
public static void main(String args[])
{
//检查类上是否有注解对象
if(AnnotationApplication.class.isAnnotationPresent(AnnotationExample.class))
{
//得到注解对象，只有当注解上被标记了元注解@Retention(RetentionPolicy.RUNTIME)时才会被保留到运行期间
AnnotationExample ae = (AnnotationExample)AnnotationApplication.class.getAnnotation(AnnotationExample.class);
}
}
}

1
2
3
4
5
6
public @interface AnnotationExample
{
String name() default "custom";//属性默认值为custom
String value();//当且仅当注解只有一个属性需要赋值时，可以直接用双引号+值进行赋值
MetaAnnotation annotationAttr() default @MetaAnnotation("change");;
}

1
2
3
4
@AnnotationExample("value")//如果要对两个属性都进行赋值，就必须这么写@AnnotationExample(annotationAttr=@MetaAnnotation("fix"),name="name",value="value")
public class AnnotationApplication
{
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 方式1：继承Thread类
*/
public class ThreadTest extends Thread {
/**
* 重写（Override）run()方法 JVM会自动调用该方法
*/
@Override
public void run() {
System.out.println("I'm running!");
}
/**
* 重载（Overload）run()方法 和普通的方法一样，并不会在该线程的start()方法被调用后被JVM自动运行
*/
public void run(int times) {
System.out.println("I'm running!(Overload)");
}
}

1
2
3
4
5
6
7
8
/**
* 方式2：实现Runnable接口
*/
public class ThreadTest implements Runnable {
public void run() {
System.out.println("I'm running!");
}
}

1
2
3
4
5
6
7
//1）如果线程是继承Thread类，则创建方式如下：
ThreadTest1 tt = new ThreadTest1();
tt.start();
//2）如果是实现Runnable接口，则创建方式如下：
ThreadTest2 tt = new ThreadTest2();
Thread t = new Thread(tt);
t.start();

1
2
3
4
5
6
7
Properties pro = System.getProperties();//获得系统属性
System.setProperty("myKey","myValue');//设置系统属性
for(Object obj : pro.keySet())//Properties是Hashtable的子类（通过JavaAPI查得），也是Map的子类，那么可以通过Map的方法取出其中的元素
{
String tmp = (String)pro.get(obj);//Properties集合中存储的都是字符串
System.out.println(obj + " :: " + tmp);//系统属性用处很大，比如：可以通过系统属性得知当前操作系统是什么，然后判断是否能安装本软件
}

1
2
3
4
Runtime r = Runtime.getRuntime();//获得Runtime对象（单例模式）
Process p = r.exec("winmine.exe");//启动进程
Thread.sleep(4000);//线程休息4000毫秒
p.destroy();//杀死进程（只能杀死Runtime启动的进程）

1
2
3
4
5
Date d = new Date();
System.out.println(d);//默认以系统格式显示，往往满足不了我们的需要
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");//将模式封装到SimpleDateFormat对象中，JavaAPI有详尽的格式介绍
String time = sdf.format(d);//返回字符串，如要进行日期计算就需要额外转换（麻烦）
System.out.println("time= " + time);

1
2
3
4
Calendar c = Calendar.getInstance();
c.add(Calendar.MONTH,-1);//月份减1，eg：1月-1=12月
String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};//使用下标法将数字转换成中文
System.out.println(c.get(Calendar.YEAR) + "年" + mons[c.get(Calendar.MONTH)] + "月");

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
//写演示
FileWriter fw = null;
try
{
fw = new FileWriter("demo.txt");//建立字符流，它会抛出一个IO异常
//fw = new FileWriter("demo.txt",true);//FileWriter的第二个构造函数，指定为true后启用追加修改
fw.write("Testing1");//写入数据，暂存于缓存
fw.flush();//刷新流，将缓冲区的数据写入文件
fw.write("Testing2");
}
catch(IOException e)//FileNotFoundException是IOException的一个子类
{
System.out.println(e.toString());
}
finally
{
try
{
if(fw != null)
fw.close();//刷新流，并关闭流
}
catch(IOException e)//如果初始化抛出异常而没创建成功，那么执行fw.close()就会得到异常
{
System.out.println(e.toString());
}
}
//读演示
FileReader fr = new FileReader("demo.txt");//读取文件
int ch = 0;
while((ch = fr.read()) != -1)//读取方式一，单个字符读取
{
System.out.print((char)ch);
}
char[] buf = new char[1024];
int num = 0;
while((num = fr.read(buf)) != -1)//读取方式二，以定长字符数组作为缓存读取
{
System.out.print(new String(buf,0,num));
}

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
FileReader fr = null;
FileWriter fw = null;
try
{
fr = new FileReader("Source.txt");
fw = new FileWriter("Destination.txt");
char[] buf = new char[1024];
int len = 0;
while((len = (fr.read(buf)) != -1)//把字符读取到缓冲字符数组buf中
{
fw.write(buf,0,len);//将缓冲字符数组buf的内容写入
}
}
catch(IOException e)
{
throw new RuntimeException("复制失败");
}
finally
{
try
{
if(fr != null)
fr.close();
}
catch(IOException e){}
try
{
if(fw != null)
fw.close();
}
catch(IOException e){}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//写演示
FileWriter fw = new FileWriter("demo.txt");
BufferedWriter bw = new BufferedWriter(fw);//缓冲技术的关键是在其中封装了数组
bw.write("testing");
bw.newLine();//这是为了避免不同操作系统中换行符表示不同所采用的
bw.flush();
bw.close();
fw.close();
//读演示
FileReader fr = new FileReader("demo.txt");
BufferedReader br = new BufferedReader(fr);
String line = null;
while((line = br.readLine()) != null)
{
System.out.println(line);
}
br.close();
fr.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
public class MyBufferedReader//这里使用了“装饰设计模式”，想要对已有对象进行增强时，将已有对象传入，基于已有功能，提供加强功能，那么自定义的该类称为装饰类
{
private Reader r = null;
public MyBufferedReader(Reader r)//原有类通过构造方法传入
{
this.r = r;
}
public String myReadLine() throws IOException//对原有类进行增强
{
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch = r.read()) != -1)
{
if(ch == 'r')
continue;
if(ch == 'n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length != 0)
return sb.toString();
return null;
}
public void myClose() throws IOException
{
r.close();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//读操作1
FileInputStream fis = new FileInputStream("demo.txt");
byte[] buf = new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
fis.close();
//读操作2
FileIutputSteam fis = new FileIutputStream("demo.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
//写操作
FileOutputStream fos = new FileOutputStream("demo.txt");
fos.write("abcdefg".getBytes());
fos.close();

1
2
3
4
5
6
7
8
FileOutputStream fos = new FileOutputStream("c:\2.bmp");
FileInputStream fis = new FileInputStream("c:\1.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
fos.write(buf,0,len);
}

1
2
3
4
5
6
7
8
9
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("demo.txt"));//不难发现使用方式与字符流类似
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("demo2.txt"));
int buf = 0;
while((buf = bis.read()) != -1)
{
fos.write(buf);
}
bis.close();
bos.close();

1
2
3
4
InputStream in = System.in;//in标准“输入流”，从键盘
out标准“输出流”，到控制台
int buf = in.read();//等待用户输入
System.out.println(buf);

1
2
3
4
5
6
7
InputStream in = System.in;
InputStreamReader isr = new InputStreamReader(in);//将字节流转换为字符流
BufferedReader br = new BufferedReader(isr);//br.read()
//之后操作参考上面的例子,同样，也有字符流转换字节流的OutputStreamWriter
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bw = new BufferedWriter(osw);

1
System.setIn(new FileInputStream("Demo.txt"));//该方法可改变输入源，同样也有改变输出源的System.setOut(new PrintStream("demo.txt"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//实现一
catch(Exception e)
{
e.printStackTrace(new PrintStream("Exception_log.txt"));//将错误信息输出到Exception_log.txt日志中，注意：PrintStream本身还会抛出异常需要处理
}
//实现二
catch(Exception e)
{
Date d = new Date();
PrintStream ps = new PrintStream("Exception_log.txt");
ps.print(d.toString());//在输出错误信息前加入时间信息
System.setOut(ps);
e.printStackTrace(System.out);//通过改变输出源，将错误信息保存进日志，也可以在此加入时间
}

1
2
Properties p = System.getProperties();
p.list(new PrintStream("Exception_log.txt"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
File f = new File("c:"+File.separator()+"demo.txt");//separator方法提供跨平台文件的分隔符
f.createNewFile();//创建成功返回true
f.delete();//删除文件
f.createTempFile();//创建临时文件，用于保存程序运行发生的临时数据（故障恢复时用）
f.deleteOnExit();//在程序退出时删除文件，通常和创建临时文件一起使用
f.getPath();//获得相对路径，Result：demo.txt
f.getAbsolutePath();//获得绝对路径，Result:c:demo.txt
//文件过滤
File f = new File("c:\");
String[] arr = f.list(new FilenameFilter(){
public boolean accept(File dir,String name)
{
System.out.println(dir+"
"+name);
/*以下是错误的示范
if(name.endsWith(".bmp"))
return true;
else
return false;
*/
return name.endsWith(".bmp");
}
});
//学会查看JavaAPI，需要时查阅，再做一些简单的测试既能掌握它的用法，Java的产生主旨就是要让编程变得简单!

1
2
3
4
5
6
7
Properties p = new Properties();
FileInputStream fis = new FileInputStream("config.txt");
p.load(fis);//load方法通过流读取某一配置文件中的配置信息（载入配置文件）
p.list(System.out);//将信息输出到控制台
p.setProperty("myKey","myValue);//修改某一属性值
FileOutputStream fos = new FileOutputStream("config.txt");
p.store(fos);//保存配置信息

1
2
3
4
5
6
7
8
9
BufferedReader br = new BufferedReader(new InputStream(System.in));
PrintWriter pw = new PrintWriter(System.out,true);
String line = null;
while((line = br.readLine()) != null)
{
pw.println(line);
}
pw.close();
br.close();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("demo1.txt"));
v.add(new FileInputStream("demo2.txt"));
v.add(new FileInputStream("demo3.txt"));
Enumeration<FileInputStream> enum = v.elements();
SequenceInputStream sis = new SequenceInputStream(enum);
FileOutputStream fos = new FileOutputStream("Destination.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = sis.read(buf)) != -1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();

1
2
3
4
5
6
7
8
9
10
FileInputStream fis = new FileInputStream("Source.txt");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0,count = 0;
while((len = fis.read(buf)) != -1)
{
fos = new FileOutputStream((count++) + ".part");//以文件切割次数作为碎片的序列名称
fos.write(buf,0,len);
fos.close();
}

1
2
3
4
5
6
7
8
9
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj_tmp.txt"));
oos.writeObject(new ObjDemo("value",111));//向文本写入一个对象
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj_tmp.txt"));
ObjDemo od1 = (ObjDemo)ois.readObject();
System.out.println(od1);
ois.close();
//至此，可以进行初步的对象序列化（即存入磁盘），但当原有的ObjDemo发生改变（比如其中的name属性由public变为private），被序列化的obj_tmp就无法匹配新对象了。此时，让ObjDemo继承Serializable对象，并且给定固定标识（static final long serialVersionUID = 42L），就能保证新类也能匹配旧的序列化对象
//注意：transient可关键词用于修饰不想被序列化的属性

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
class Read implements Runable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
byte[] buf = new byte[1024];
System.out.println("Read:start reading...");
int len = in.read(buf);//阻塞读取数据，若无数据进入等待状态
System.out.println("Read:read over.");
String s = new String(buf,0,len);
System.out.println(s);
in.close();
}
}
class Write implements Runable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
System.out.println("Write:stop 6ms...")
Thread.sleep(6000);
out.write("piped is come in".getBytes());//写数据
out.close();
}
}
main
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);//连接管道
Read r = new Read();
Write w = new Write();
new Thread(r).start();
new Thread(w).start();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
RandomAccessFile raf = new RandomAccessFile("demo.txt","rw);
raf.write("value1".getBytes());
raf.writeInt(97);
raf.write("value2".getBytes());
raf.writeInt(99);
raf.close();
//输出完成，下面开始输入
RandomAccessFile raf = new RandomAccessFile("demo.txt","rw);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println(name+" "+age);
//若只想取第二个数据
RandomAccessFile raf = new RandomAccessFile("demo.txt","rw);
raf.seek(8);//指针向前偏移8个字节，使用此方法的前提是数据必须具有规律性！
//raf.skipBytes(8);效果同seek，但seek可以前移后移，但skipBytes只能后移！
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println(name+" "+age);
//流在操作数据时只能按顺序读或写，但RandomAccessFile允许跳至任何位置写（即随机写），就是使用seek&skipBytes方法实现的！

1
2
3
4
5
6
InetAddress address = InetAddress.getLocalHost();
address = InetAddress.getByName("www.infoq.com");
InetAddress[] address = InetAddress.getAllByName("www.baidu.com");//获得该主机名的所有IP
//以上3个方法都是创建InetAddress实例（工厂方法）
System.out.println(address.getHostAddress());
System.out.println(address.getHostName());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//数据发送
DatagramSocket ds_send = new DatagramSocket();//1、通过DatagramSocket对象创建UDP服务（发送端），若不指定端口，系统会自动分配端口
byte[] buf = "this is a udp package.".getBytes();//2、确定数据，并封装成数据包
DatagramPacket dp_send = new DatagramPacket(buf, buf.length, InetAddress.getByName("127.0.0.1"), 10000);
ds_send.sent(dp_send);//3、通过Socket服务，将已有数据包通过send()发送出去
ds_send.close();//4、关闭资源
//数据接收
DatagramSocket ds_receive = new DatagramSocket(10000);//1、通过DatagramSocket对象创建UDP服务（接收端），指定监听端口
byte[] buf = new bytes[1024];//2、定义数据包，用于存储数据
DatagramPacket dp_receive = new DatagramPacket(buf, buf.length);
ds_receive.receive(dp_receive);//3、通过receive()将数据接收到数据包中，阻塞式方法，未接收到数据就等待
String ip = dp_receive.getAddress().getHostAddress();//4、通过数据包的方式获取其中的数据
String data = new String(dp_receive.getData(), 0, dp_receive.getLength());
int port = dp_receive.getPort();
System.out.println(ip + " : " + prot + " :: " + data);
ds_receive.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
//发送端
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket ds_send = new DatagramSocket(10002);
String line = null;
while(null != (line = br.readLine))
{
if(line.equals("886"))
break;
byte buf = line.getBytes();
DatagramPacket dp_send = new DatagramPacket(buf, buf.length, InetAddress.getByName("127.0.0.1"), 10001);
ds_send.sent(dp_send);
}
ds_send.close();
//接收端
DatagramSocket ds_receive = new DatagramSocket(10001);
while(true)
{
byte[] buf = new bytes[1024];
DatagramPacket dp_receive = new DatagramPacket(buf, buf.length);
ds_receive.receive(dp_receive);
String ip = dp_receive.getAddress().getHostAddress();
String data = new String(dp_receive.getData(), 0, dp_receive.getLength());
int port = dp_receive.getPort();
System.out.println(ip + " : " + prot + " :: " + data);
}
ds_receive.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
54
55
//发送线程
class Send implements Runnable
{
private DatagramSocket ds;
public Send(DatagramSocket ds)
{
this.ds = ds;
}
public void run()
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
while(null != (line = br.readLine()))
{
if("886".equals(line))
break;
byte[] buf = line.getBytes();
DatagramPacket dp = new DatagramPocket(buf, buf.length, InetAdress.getByName("127.0.0.1"), 10002);
ds.send(dp);
}
ds.close();
}
}
//接收线程
class Receive implements Runnable
{
private DatagramSocket ds;
public Receive(DatagramSocket ds)
{
this.ds = ds;
}
public void run()
{
while(true)
{
byte[] buf = new byte[1024];
DatagramPocket dp = new DatagramPocket(buf, buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(), 0, dp.getLength());
System.out.println(ip + " : " + data);
}
ds.close();
}
}
//主线程
public class ChatDemo
{
public static void main(String[] args)
{
DatagramSocket sendSocket = new DatagramSocket();
DatagramSocket receiveSocket = new DatagramSocket(10002);
new Thread(new Send(sendSocket)).start();
new Thread(new Receive(receiveSocket)).start();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//客户端
Socket s = new Socket("127.0.0.1", 10003);//创建客户端的Socket，指定目的主机和端口
OutputStream os = s.getOutputStream();//为了发送数据，应该获取Socket流中的输出流
os.write("this is a tcp message.".getBytes());
InputStream is = s.getInputStream();//阻塞式方法等待数据
byte[] buf = new byte[1024];
int len = is.read(buf);
System.out.println(new String(buf, 0, len));
os.close();
is.close();
s.close();
//服务端
ServerSocket ss = new ServerSocket(10003);//建立服务端Socket，并监听一个端口
Socket s = ss.accept();//通过accept()获取连接过来的客户端对象
InputStream is = s.getInputStream();//使用读取流获取客户端发送来的数据，阻塞式方法等待数据
byte buf = new byte[1024];
int len = is.read(buf);
System.out.println(s.getInetAddress().getHostAddress() + " : " + new String(buf, 0, len));
OutputStream os = s.getOutputStream();
os.write("recevie success!".getBytes());
is.close();
os.close();
s.close();//关闭该客户端Socket，释放资源

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
//客户端
class PicClient
{
public static void main(String[] args)
{
Socket s = new Socket("127.0.0.1", 10005);
FileInputStream fis = new FileInputStream("c:\test.bmp");
OutputStream os = s.getOutputStream();
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
os.write(buf, 0, len);
}
s.shutdownOutput();//告诉服务端数据已写完
InputStream is = s.getInputStream();
len = is.read(buf);
System.out.println(new String(buf, 0, len));
fis.close();
os.close();
is.close();
s.close();
}
}
//服务端
class PicServerThread implements Runnable
{
private Socket s;
PicServerThread(Socket s)
{
this.s = s;
}
public void run()
{
int count = 1;
String ip = s.getInetAddress().getHostAddress();
InputStream is = s.getInputStream();
File file = new File(ip + "(" + count + ")" + "_test.bmp");
while(file.exists())//如果名字存在，计数+1
file = new File(ip + "(" + count + ")" + "_test.bmp");
FileOutputStream fos = new FileOutputStream(ip + "_test.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len = is.read(buf)) != -1)
{
fos.write(buf, 0, len);
}
OutputStream os = s.getOutputStream();
os.write("receive success!".getBytes());
fos.close();
os.close();
is.close();
s.close();
}
}
class PicServer
{
public static void main(String[] args)
{
ServerSocket ss = new ServerSocket(10005);
while(true)
{
Socket s = ss.accept();
new Thread(new PicServerThread(s)).start();
}
ss.close();
}
}

1
2
3
4
5
6
7
ServerSocket ss = new ServerSocket(11000);
Socket s = ss.accept();
System.out.println(s.getInetAddress().getHostAddress());
PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
pw.println("<font color='red' size='7'>Hello,Client!</font>");
s.close();
ss.close();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
String path = "/myweb/demo.html";//如果使用图形化界面，可通过修改path改变访问地址
Socket s = new Socket("192.168.1.1", 8080);
PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
out.println("GET + path + HTP/1.1");
out.println("Accept: */*");
out.println("Accept-Language: zh-cn");
out.println("Host: 192.168.1.1:11000");
out.println("Connection: closed");
out.println();
out.println();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line = br.read()) != null)
{
System.out.println(line);
}
s.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
URL url = new URL("http://java.sun.com:80/docs/books/demo.html?name=test&age=30");
String protocol = url.getProtocol();
String host = url.getHost();
String file = url.getFile();//获得目录/docs/books/demo.html?name=test&age=30
String query = url.getQuery();//获得?后边的参数name=test&age=30
int port = url.getPort();
String ref = url.getRef();
//将infoq的页面通过I/O Stream保存至本地
URL url = new URL("http://www.infoq.com");
URLConnection conn = url.openConnection();
InputStream is = conn.getInputStream();
//以上2句等价于InputStream is = url.openStream();
OutputStream os = new FileOutputStream("c:\infoq.txt");
byte[] buf = new byte[2048];
int length = 0;
while(-1 != (length = is.read(buf, 0, buf.length)))
os.write(buf, 0, length);
is.close();
os.close();
//使用字符流+缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
String line = null;
while(null != (line = br.readLine()))
System.out.println(line);

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/**
* 1、加载JDBC驱动程序：<br/>
* 在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），<br/>
* 这通过java.lang.Class类的静态方法forName(String className)实现。
*/
try
{
// 加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver");
}
catch (ClassNotFoundException e)
{
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace();
}
// 成功加载后，会将Driver类的实例注册到DriverManager类中。
/**
* 2、提供JDBC连接的URL：<br/>
* 连接URL定义了连接数据库时的协议、子协议、数据源标识。 <br/>
* 书写形式——协议：子协议：数据源标识<br/>
* 协议：在JDBC中总是以jdbc开始。<br/>
* 子协议：是桥连接的驱动程序或是数据库管理系统名称。<br/>
* 数据源标识：标记找到数据库来源的地址与连接端口。
*/
String url = "jdbc:mysql://192.168.137.211/test?useUnicode=true&characterEncoding=utf-8";
// useUnicode=true：表示使用Unicode字符集。如果characterEncoding设置为gb2312或GBK，本参数必须设置为true。characterEncoding=utf-8：字符编码方式。
/**
* 3、创建数据库的连接：<br/>
* 要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，该对象就代表一个数据库的连接。<br/>
* 使用DriverManager的getConnectin(String url , String username , String
* password )方法传入指定的欲连接的数据库的路径、数据库的用户名和 密码来获得。
*/
String username = "root";
String password = "root";
Connection conn = null;
try
{
conn = DriverManager.getConnection(url, username, password);
}
catch (SQLException se)
{
System.out.println("数据库连接失败！");
se.printStackTrace();
}
/**
* 4、创建一个Statement：<br/>
* 要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3 种类型：<br/>
* 1、执行静态SQL语句。通常通过Statement实例实现。<br/>
* 2、执行动态SQL语句。通常通过PreparedStatement实例实现。<br/>
* 3、执行数据库存储过程。通常通过CallableStatement实例实现。
*/
Statement stmt = conn.createStatement();
PreparedStatement pstmt = conn.prepareStatement("sql");
CallableStatement cstmt = conn.prepareCall("{CALL demoSp(? , ?)}");
/**
* 5、执行SQL语句：<br/>
* Statement接口提供了三种执行SQL语句的方法：executeQuery、executeUpdate和execute。<br/>
* 1、ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句
* ，返回一个结果集（ResultSet）对象。<br/>
* 2、int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或
* DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等。<br/>
* 3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的语句。
*/
ResultSet rs = stmt.executeQuery("SELECT * FROM ...");
int rows = stmt.executeUpdate("INSERT INTO ...");
boolean flag = stmt.execute("sql");
/**
* 6、处理结果 两种情况：<br/>
* 1、执行更新返回的是本次操作影响到的记录数。<br/>
* 2、执行查询返回的结果是一个ResultSet对象。
* ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些 行中数据的访问。
* 使用结果集（ResultSet）对象的访问方法获取数据：
*/
while (rs.next())
{
String name = rs.getString("name");
String pass = rs.getString(1); // 此方法比较高效
}
// （列是从左到右编号的，并且从列1开始）
/**
* 7、关闭JDBC对象：<br/>
* 操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声明顺序相反：<br/>
* 1、关闭记录集。2、关闭声明。3、关闭连接对象。
*/
if (rs != null)
{ // 关闭记录集
try
{
rs.close();
}
catch (SQLException e)
{
e.printStackTrace();
}
}
if (stmt != null)
{ // 关闭声明
try
{
stmt.close();
}
catch (SQLException e)
{
e.printStackTrace();
}
}
if (conn != null)
{ // 关闭连接对象
try
{
conn.close();
}
catch (SQLException e)
{
e.printStackTrace();
}
}

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
Class clazzProxy1 = Proxy.getProxyClass(
Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy1.getName());
System.out
.println("------------begin constructor list------------------");
Constructor[] constructors = clazzProxy1.getConstructors();
for (Constructor constructor : constructors)
{
String name = constructor.getName();
StringBuilder sb = new StringBuilder(name);
// StringBuilder&StringBuffer的区别,应用上都是动态往字符串上加内容，
// 但StringBuffer是Thread Safe的，因此StringBuilder在Single Thread情况下效率高，
// 而Multi Thread情况下StringBuffer效率高
sb.append('{');
Class[] clazzParams = constructor.getParameterTypes();
for (Class clazzParam : clazzParams)
{
sb.append(clazzParam.getName()).append(',');
}
if (clazzParams != null && clazzParams.length != 0)
sb.deleteCharAt(sb.length() - 1);
sb.append('}');
System.out.println(sb);
}
System.out.println("------------begin method list------------------");
Method[] methods = clazzProxy1.getMethods();
for (Method method : methods)
{
String name = method.getName();
StringBuilder sb = new StringBuilder(name);
sb.append('{');
Class[] clazzParams = method.getParameterTypes();
for (Class clazzParam : clazzParams)
{
sb.append(clazzParam.getName()).append(',');
}
if (clazzParams != null && clazzParams.length != 0)
sb.deleteCharAt(sb.length() - 1);
sb.append('}');
System.out.println(sb);
}
System.out
.println("------------begin create instance-------------------");
Constructor constructor = clazzProxy1
.getConstructor(InvocationHandler.class);
class MyInvocationHandler1 implements InvocationHandler
{
@Override
// 参数的含义：proxy当前的代理对象，method代理对象的哪个方法，args方法所需参数
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
// TODO Auto-generated method stub
return null;
}
}
Collection proxy1 = (Collection) constructor
.newInstance(new MyInvocationHandler1());
System.out.println(proxy1);// null
proxy1.clear();// invoked
// proxy1.size();// java.lang.NullPointerException
Collection proxy2 = (Collection) constructor
.newInstance(new InvocationHandler()
{
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable
{
// TODO Auto-generated method stub
return null;
}
});
Collection proxy3 = (Collection) Proxy.newProxyInstance(
Collection.class.getClassLoader(),
new Class[] { Collection.class }, new InvocationHandler()
{
ArrayList target = new ArrayList();
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable
{
long beginTime = System.currentTimeMillis();//这种取得时间的方式是硬编码
Object retVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();//一旦代码被封装就无法更改，后续会进行更改
System.out.println(method.getName()
+ " time-consuming: " + (endTime - beginTime));
return retVal;
}
});
proxy3.add("111");// 若target对象写在invoke方法内部就会发生java.lang.NullPointerException
proxy3.add("222");// 我们调用proxy的add方法，proxy内部调用invoke方法，获得返回值retVal
System.out.println(proxy3.size());
// 疑问：proxy3内部target是一个ArrayList，但为何打印其名结果仍是sun.proxy.$Proxy0呢？
// 答案：所有Proxy都继承自Java根类Object，而Java只把hashCode、equals、toString三个方法交由Handler实现。
// 除这三个方法以外的Object中的其他方法都有自己的实现，因此输出结果是sun.proxy.$Proxy0
System.out.println(proxy3.getClass().getName());

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
//Advice.java
public interface Advice
{
// Advice代表Java的系统建议，一般有5个方法，异常、方法内前后、方法外前后
public void beforeMethod(Method method);
public void afterMethod(Method method);
}
//MyAdvice.java
public class MyAdvice implements Advice
{
long beginTime;
long endTime;
@Override
public void beforeMethod(Method method)
{
beginTime = System.currentTimeMillis();
}
@Override
public void afterMethod(Method method)
{
endTime = System.currentTimeMillis();
System.out.println(method.getName() + " time-consuming: "
+ (endTime - beginTime));
}
}
//ProxyTest.java
public class ProxyTest
{
public static void main(String[] args) throws Exception
{
Collection proxy3 = (Collection) getProxy(new ArrayList(),
new MyAdvice());
}
private static Object getProxy(final Object target, final Advice advice)
{
Object proxy3 = Proxy.newProxyInstance(target.getClass()
.getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler()
{
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable
{
// long beginTime = System.currentTimeMillis();
advice.beforeMethod(method);
Object retVal = method.invoke(target, args);
// long endTime = System.currentTimeMillis();
// System.out.println(method.getName()+" time-consuming: " + (endTime - beginTime));
advice.afterMethod(method);
return retVal;
}
});
return proxy3;
}
}