java-API 全——超过4000行
**API**
字符串一旦创建，对象永远无法改变，但字符串引用可以重新赋值。
java字符串中任何一个字符对应16位(两个字节)的定长Unicode编码。
/**
* int length()
* 返回当前字符串长度(字符个数)
* @author
*/
public static void main(String[] args) {
String str = "我爱java";
System.out.println("len:"+str.length());
}}
/**
* int indexOf(String str)
* 返回给定字符串在当前字符串中的位置，若当
* 前字符串不包含该内容则返回值为-1
* @author
*/
public static void main(String[] args) {
// 0123456789012345
String str = "thinking in java";
int index = str.indexOf("in");
System.out.println("index:"+index);
//可以从指定位置开始查找
index = str.indexOf("in", 3);
System.out.println("index:"+index);
//查找最后一次出现的位置
index = str.lastIndexOf("in");
System.out.println("index:"+index);
}}
/**
* String substring(int start,int end)
* 截取指定范围内的字符串。两个参数为开始到
* 结束的下标。
* 注:java api有一个特点，通常用两个数字表示
* 范围时都是"含头不含尾"的。
* @author
*/
public static void main(String[] args) {
// 0123456789012
String host = "";
String sub = host.substring(4, 9);
System.out.println(sub);
//一个参数为截取到末尾
sub = host.substring(4);
System.out.println(sub);
}}
/**
* char charAt(int index)
* 获取当前字符串中指定位置处对应的字符
* @author
*/
public static void main(String[] args) {
// 0123456789012345
String str = "thinking in java";
char c = str.charAt(9);
System.out.println(c);
/*
* 判断回文
* 上海自来水来自海上
*/
str = "上海自来水自来海上";
for(int i=0;i<str.length()/2;i++) {
char c1 = str.charAt(i);
char c2 = str.charAt(str.length()-1-i);
if(c1!=c2) {
System.out.print("不");
break;
}
}
System.out.println("是回文");
}}
/**
* String支持正则表达式方法之一:
* boolean matches(String regex)
* 用给定的正则表达式验证当前字符串是否符合
* 其格式要求。
* @author
*/
public static void main(String[] args) {
String email = "fancq@";
/*
* 验证email格式的正则表达式
* \w+@\w+(\.[a-zA-Z]+)+
*/
String regex = "\\w+@\\w+(\\.[a-zA-Z]+)+";
/*
* 注意:matches方法指定的正则表达式就算不
* 指定边界匹配符，也是做全匹配验证的。
*/
boolean match = email.matches(regex);
if(match) {
System.out.println("是邮箱");
}else {
System.out.println("不是邮箱");
} }}
/**
* String replaceAll(String regex,String str)
* 将当前字符串中符合正则表达式要求的部分替换
* 为给定内容
* @author
*/
public static void main(String[] args) {
String str = "abc123def456ghi789jkl";
/*
* 将数字部分替换为"#NUMBER#"
*/
String regex = "[0-9]+";
str = str.replaceAll(regex, "#NUMBER#");
System.out.println(str);
}}
import java.util.Arrays;
/**
* String[] split(String regex)
* 使用给定的正则表达式来拆分当前字符串。
* 并将拆分后的内容以字符串数组形式返回。
* @author
*/
public static void main(String[] args) {
String str = "abc123def456jhi789klm";
String[] array = str.split( "[0-9]+");//0-9全部去除
System.out.println(array.length);
System.out.println(Arrays.toString(array));
}}
/**
* boolean startsWith(String str)开始
* boolean endsWith(String str) 结尾
* 判断当前字符串是否是以给定字符串开始或
* 结尾的。
* @author
*/
public static void main(String[] args) {
String str = "thinking in java";
//开始
boolean starts = str.startsWith("thi");
System.out.println("starts:"+starts);
//结尾
boolean ends = str.endsWith("va");
System.out.println("ends:"+ends);
}}
/**
* StringBuilder专门用来修改字符串内容的API.
* String由于其优化设计导致的问题就是不能频繁
* 修改(每次都创建新对象)
* @author
*/
public static void main(String[] args) {
String str = "努力学习java";
//默认表示空字符串
//StringBuilder builder= new StringBuilder();
StringBuilder builder
= new StringBuilder(str);
/*
* 拼接字符串append()
*/
builder.append(",为了找个好工作!");
/*
* StringBuilder的toString方法用来
* 获取其内部表示的字符串内容toString
*/
str = builder.toString();
System.out.println(str);
/*
* 努力学习java,为了找个好工作!
* 努力学习java,就是为了改变世界!
*定向改变字符内容replace()
* replace()
*/
builder.replace(9, 16, "就是为了改变世界");
System.out.println(builder);
/*
* 努力学习java,就是为了改变世界!
* ,就是为了改变世界!
*定向删除字符内容delete()
* delete()
*/
builder.delete(0, 8);
System.out.println(builder.toString());
/*
* ,就是为了改变世界!
* 活着,就是为了改变世界!
*指定位置添加内容 insert()
* insert()
*/
builder.insert(0,"活着");
System.out.println(builder.toString());
}}
/**
* StringBuilder修改性能
* @author
*/
public static void main(String[] args) {
StringBuilder builder = new StringBuilder("a");
for(int i=0;i<10000000;i++) {
builder.append("a");
}
System.out.println("执行完毕!");
}}
/**
* 字符串频繁修改带来的性能损耗
*String是不变对象，每次内容更改都是创建新对象
* @author
*/
public static void main(String[] args) {
String str = "a";
for(int i=0;i<10000000;i++) {
str += "a";
//系统需要很长很长时间才能运行出结果，a结果有无数个
}
System.out.println("执行完毕!");
}}
/*StringBuffer 和 StringBuilder 的区别
StringBuffer是线程安全的，同步处理的，性能稍慢
StringBuilder是非线程安全的，兵法处理的，性能稍快*/
/**
* String是不变对象，JVM对其做了一个优化，在内存
* 中开辟了一段区域作为常量池，凡是通过"字面量"形
* 式创建的字符串对象都会缓存并重用。因为会重用
* 对象，所以该对象内容不可变。
* @author
*/
public static void main(String[] args) {
String s1 = "123abc";
//s2,s3重用s1创建的字符串对象
String s2 = "123abc";
String s3 = "123abc";
System.out.println(s1==s2);//true
System.out.println(s1==s3);//true
//修改内容会创建并引用新对象
s1 = s1+"!";
System.out.println("s1:"+s1);
//s2,s3不受影响
System.out.println("s2:"+s2);
//new则一定创建新对象
String s4 = new String("123abc");
System.out.println("s4:"+s4);
System.out.println(s2==s4);//false
/*
* 编译器有一个优化措施，当编译源代码
* 时发现一个计算表达式所有参数都是字面
* 量时，会直接进行计算，并将结果编译到
* class文件中。
* 所以，下面的代码在class文件中为:
* String s5 = "123abc";
*/
String s5 = "123"+"abc";
System.out.println("s5:"+s5);
System.out.println(s2==s5);//true
/*
* 计算表达式一方为变量，那么会在运行期
* 拼接，那么会创建新对象
*/
String s = "123";
String s6 = s + "abc";
System.out.println("s6:"+s6);
System.out.println(s2==s6);//false
} }
/**
* String substring(int start,int end)
* 完成方法，获取给定地址中的域名
* @author
*/
public static void main(String[] args) {
String url = "";
String name = getHostName(url);
System.out.println(name);//sohu
url = "";
name = getHostName(url);
System.out.println(name);//tedu
}
public static String getHostName(String url) {
int start = url.indexOf(".")+1;
int end = url.indexOf(".",start);
return url.substring(start, end);
}}
/**
* 要求用户从控制台输入一个email地址，然后获取该email的用户名(@之前的内容)
* @author
*/
import java.util.Scanner;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入email");
String num = scan.next();
/**
* int indexOf(String str)
* 返回给定字符串在当前字符串中的位置，若当
* 前字符串不包含该内容则返回值为-1
* @author
*/
int index = num.indexOf("@");
/**
* String substring(int start,int end)
* 截取指定范围内的字符串。两个参数为开始到
* 结束的下标。
* 注:java api有一个特点，通常用两个数字表示
* 范围时都是"含头不含尾"的。
* @author
*/
String ss = num.substring(0, index);
System.out.println(ss);
import java.util.Date;
/**
* String imageRename(name)
* 图片重命名
* @author
*/
public static void main(String[] args) {
String imageName = "";
imageName = imageRename(imageName);
System.out.println(imageName);
}
public static String imageRename(String imageName) {
//按照"."拆分
String[] data = imageName.split("\\.");
imageName
= System.currentTimeMillis()+"."+data[1];
return imageName;
}}
/**
*replaceAll(indet，String "**")
* 和谐用语
* @author
*/
public static void main(String[] args) {
String regex = "(wqnmlgdsb|mmp|nc|mdzz|cnm|djb)";
String message = "wqnmlgdsb!你怎么这么nc!cnm,你个djb!";
message = message.replaceAll(regex, "***");
System.out.println(message);
}}
/**
* String toUpperCase()//大写
* String toLowerCase()//小写
* 将当前字符串中的英文部分转换为全大写或者全小写
* @author
*/
public static void main(String[] args) {
String str = "我爱Java";
//大写
String upper = str.toUpperCase();
System.out.println("upper:"+upper);
//小写
String lower = str.toLowerCase();
System.out.println("lower:"+lower);
}}
/**
* String trim()
* 去除一个字符串两边的空白字符
* @author
*/
public static void main(String[] args) {
String str = " hello ";
System.out.println(str);
String trim = str.trim();
System.out.println(trim);
}}
/**
* String提供了一组重载的静态方法:valueOf
* 可以将给定的内容转换为字符串
* @author
*/
public static void main(String[] args) {
int d = 1;
String str = String.valueOf(d);
System.out.println(str);
double dou = 1.1;
str = String.valueOf(dou);
System.out.println(str);
str = d+"";
}}
/**
* 使用当前类测试重写Object相关方法
* @author
*/
public class Point {
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
/**
* toString方法会被很多API调用。所以当我们
* 定义一个类时，很常见的操作就是重写这个
* 方法。
* 该方法的意义是将当前对象转换为一个字符串
* 形式。该字符串内容格式没有严格的要求。
* 原则为包含这个对象的相关属性信息。
*/
public String toString() {
//(1,2)
return "("+x+","+y+")";
}
/**
* equals的作用是比较当前对象与参数对象
* 的内容是否一致。
*/
public boolean equals(Object obj) {
if(obj==null) {
return false;
}
if(this==obj) {
return true;
}
if(obj instanceof Point) {
Point p = (Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}}
/**
* 测试Point重写的Object相关方法
* @author
*/
public static void main(String[] args) {
Point p = new Point(1,2);
/*
* 通常我们定义的类如果需要使用到
* toString方法时，就应当重写这个
* 方法，Object提供的输出的是该对象
* 的句柄，没有什么实际意义
*/
String str = p.toString();
System.out.println(str);
/*
* (Object obj)
* 该方法会将给定对象的toString方法
* 返回的字符串输出到控制台
*/
System.out.println(p);
Point p2 = new Point(1,2);
System.out.println(p==p2);//false
/*
* 我们定义的类如果使用equals，就应当
* 重写这个方法。Object提供的equals方法
* 本身内部就是用“==”进行比较的，没有
* 实际意义。
* 而java API提供的类，toString,equals
* 方法都妥善进行了重写。
*/
System.out.println(p.equals(p2));//true
}}
/**
* JDK1.5版本推出时推出了一个特性:
* 自动拆装箱
* 该特性是编译器认可的，当我们在基本类型和
* 其对应的引用类型之间互相赋值时，编译器会
* 自动补全代码在两者之间进行转换。
* @author
*/
public static void main(String[] args) {
/*
* 触发了编译器的自动拆箱特性:
* 编译器会补全代码，将包装类转换为
* 基本类型。
* 下面的代码会被编译器补充代码为:
* int d = new Integer(1).intValue();
*/
int d = new Integer(1);
/*
* 触发自动装箱特性，编译器会补充代码
* Integer i = (d);
*/
Integer i = d;
}}
/**
* 包装类
* 包装类是为了解决基本类型不能直接参与面向
* 对象开发的问题。
* 其中6个数字类型的包装类继承自Number类。
* 是一个抽象类，定义了几个
* 抽象方法，要求数字类型的包装类可以将其表示
* 的数字以任意数字类型返回。
* @author
*/
public class IntegerDemo1 {
public static void main(String[] args) {
int d = 128;
//转换为包装类
//Integer i1 = new Integer(d);
//Integer i2 = new Integer(d);
//推荐用valueOf转换为包装类
Integer i1 = Integer.valueOf(d);
Integer i2 = Integer.valueOf(d);
System.out.println(i1==i2);
System.out.println(i1.equals(i2));
/*
* 包装类转换为基本类型
*/
d = i1.intValue();
System.out.println(d);
double dou = i1.doubleValue();
System.out.println(dou);
byte b = i1.byteValue();
System.out.println(b);
/*
* 数字类型的包装类都定义了两个常量
* MAX_VALUE 最大值
* MIN_VALUE 最小值
* 用于表示该包装类对应的基本类型的
* 取值范围
*/
int imax = Integer.MAX_VALUE;
System.out.println(imax);
int imin = Integer.MIN_VALUE;
System.out.println(imin);
long lmax = Long.MAX_VALUE;
System.out.println(lmax);
}}
/**
* 包装类都提供了一个静态方法:
* parseXXX(String str)
* 可以将字符串解析为对应的基本类型，但是需要
* 注意，该字符串必须能够正确描述该基本类型可
* 以保存的值,否则会抛出异常。
* @author
*/
public static void main(String[] args) {
String str = "123";
int d = Integer.parseInt(str);
System.out.println(d);
double dou = Double.parseDouble(str);
System.out.println(dou);
}}
/**
* 读取文件数据
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 读取当前目录中文件内容
*/
RandomAccessFile raf
= new RandomAccessFile("","r");
/*
* int read()
* 读取一个字节，并以int形式返回。
* 若返回值为-1则表示读取到了文件末尾。
* 00000000 00000000 00000000 00000001
*/
int d = raf.read();
System.out.println(d);
d = raf.read();
System.out.println(d);//-1
raf.close();
}}
/**
* 若希望提高读写效率，可以通过提高每次实际读写
* 的数据量，减少实际发生的读写操作来做到。
* 单字节读写:随机读写
* 一组字节读写:块读写
* 机械硬盘(磁盘)的块读写效率还是比较好的。但是
* 随机读写效率极差。
* @author
*/
public static void main(String[] args) throws IOException {
RandomAccessFile src
= new RandomAccessFile("","r");
RandomAccessFile desc
= new RandomAccessFile("nox_cp.exe","rw");
/*
* RAF提供的块读写操作的方法:
* int read(byte[] data)
* 一次性读取给定的字节数组长度的字节
* 量并存入到该数组中。返回值为实际
* 读取到的字节量，若返回值为-1，表示
* 本次读取是文件末尾(没读到任何字节)
*
* void write(byte[] data)
* 一次性写出给定字节数组中的所有字节
*
* void write(byte[] data,int start,int len)
* 一次性写出给定字节数组中从start处开始的连续
* len个字节
*/
//记录每次实际读取到的字节量
int len = -1;
//每次要求读取的字节量
//10kb
byte[] data = new byte[1024*10];
long start = System.currentTimeMillis();
while((len = src.read(data))!=-1) {
desc.write(data,0,len);
}
long end= System.currentTimeMillis();
System.out.println("复制完毕!耗时"+(end-start)+"ms");
src.close();
desc.close();
}}
/**
*
* RAF是专门用来读写文件数据的API。其基于指针
* 对文件数据进行读写操作，可以灵活的编辑文件
* 数据内容。
* 创建RAF时可以指定对该文件的权限，常用的有
* 两种:
* r:只读模式
* rw:读写模式
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 对当前目录中的文件读写
* RAF支持两种常用构造方法:
* RandomAccessFile(File file,String mode)
* RandomAccessFile(String path,String mode)
*
* 注:相对路径中"./"是可以忽略不写的，因为
* 默认就是从当前目录开始。
*
* RAF创建时含有写权限的情况下，当指定的文件
* 不存在时会自动将其创建出来。
*/
RandomAccessFile raf
= new RandomAccessFile("","rw");
/*
* void write(int d)
* 向文件中写入1字节，写的是给定int值
* 对应2进制的“低八位”
* vvvvvvvv
* 00000000 00000000 00000000 00000001
* 11111111 11111111 11111111 11111111
*
*/
raf.write(1);
System.out.println("写出完毕!");
raf.close();
}}
/**
* 完成方法，实现删除给定File所表示的文件或目录
* @author
*/
public static void main(String[] args) {
File dir = new File("./a");
delete(dir);
}
/**
* 文件直接删除，目录的话要先清空该目录
* 然后再删除
* @param f
*/
public static void delete(File f) {
if(f.isDirectory()) {
//先清空该目录
File[] subs = f.listFiles();
for(int i=0;i<subs.length;i++) {
File sub = subs[i];
//递归调用
delete(sub);
}
}
f.delete();
}}
/**
* 创建一个多级目录
* @author ta
*/
public static void main(String[] args) {
/*
* 在当前目录下创建:
* a/b/c/d/e/f目录
*/
File dir = new File("./a/b/c/d/e/f");
if(!dir.exists()) {
/*
* mkdir创建目录要求父目录必须存在
* mkdirs会将不存在的父目录一同的
* 创建出来
*/
dir.mkdirs();
System.out.println("创建完毕!");
}else {
System.out.println("目录已存在!");
}}}
/**
* 创建一个目录
* @author
*/
public static void main(String[] args) {
/*
* 在当前目录中创建一个名为demo的目录
*/
File dir = new File("./demo");
if(!dir.exists()) {
dir.mkdir();
System.out.println("目录已创建");
}else {
System.out.println("目录已存在");
}}}
/**
* ListFiles提供了一个重载的方法，可以指定
* 一个文件过滤器(FileFilter),然后将满足该
* 过滤器要求的子项返回。
* @author ta
*/
public static void main(String[] args) {
/*
* 获取当前目录中名字以"."开头的子项
*/
File dir = new File(".");
FileFilter filter = new FileFilter() {
public boolean accept(File file) {
String name = file.getName();
System.out.println("正在过滤:"+name);
return name.startsWith(".");
}
};
File[] subs = dir.listFiles(filter);
System.out.println(subs.length);
for(int i=0;i<subs.length;i++) {
System.out.println(subs[i].getName());
}}}
/**
* 获取一个目录中的所有子项
* @author
*/
public static void main(String[] args) {
/*
* 获取当前目录中的所有子项
*/
File dir = new File(".");
/*
* boolean isFile()
* boolean isDirectory()
* 判断当前File对象表示的是一个文件
* 还是一个目录
*/
if(dir.isDirectory()) {
/*
* File[] listFiles()
* 该方法会将当前File表示的目录中所有
* 子项返回.
*/
File[] subs = dir.listFiles();
for(int i=0;i<subs.length;i++) {
File sub = subs[i];
System.out.println(sub.getName());
}}}}
/**
*
* File的每一个实例用于表示硬盘上的一个文件或
* 目录。
* 使用File可以:
* 1:访问其表示的文件或目录的属性信息(名字，大
* 小,访问权限等信息)
* 2:操作文件或目录(创建，删除)
* 3:访问目录子项
* 但是不能访问文件数据。
* @author
*/
public static void main(String[] args) {
/*
* 访问当前项目目录下的文件
*
* 创建File时，指定的路径通常使用相对
* 路径，好处在于:可以跨平台。
* 相对路径到底相对哪里，要看程序的
* 运行环境指定的位置。
* 在eclipse中运行java程序时，指定的
* 相对路径中"当前目录"是当前程序所在
* 的项目目录，这里就是JSD1807_SE这个
* 目录
*/
File file = new File("./");
//获取文件名
String name = file.getName();
System.out.println("name:"+name);
//获取文件大小(字节量)
long length = file.length();
System.out.println("length:"+length);
boolean cw = file.canWrite();//可写
boolean cr = file.canRead();//可读
System.out.println("可写:"+cw);
System.out.println("可读:"+cr);
boolean ih = file.isHidden();//隐藏
System.out.println("隐藏:"+ih);
}}
/**
* 删除一个文件
* @author ta
*/
public static void main(String[] args) {
/*
* 将当前目录下的文件删除
*/
File file = new File("./");
if(file.exists()) {
file.delete();
System.out.println("文件已删除");
}else {
System.out.println("文件不存在");
}}}
/**
* 删除目录
* @author
*/
public static void main(String[] args) {
/*
* 删除当前目录下的demo目录
*/
File dir = new File("./demo");
if(dir.exists()) {
/*
* 删除目录要求该目录必须是一个
* 空目录。
*/
dir.delete();
System.out.println("删除完毕!");
}else {
System.out.println("目录不存在!");
}}}
/**
* 使用File创建一个文件
* @author
*/
public class CreateNewFileDemo {
public static void main(String[] args) throws IOException {
/*
* 在当前目录下创建一个名为:
* 的文件
*/
File file = new File("./");
if(!file.exists()) {
file.createNewFile();
System.out.println("文件已创建");
}else {
System.out.println("文件已存在");
}}}
/**
* 写入字符串操作
* @author
*/
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("","rw");
String line = "大家好，我是渣渣辉。";
/*
* String提供了转换为2进制的方法:
* byte[] getBytes();
*/
//byte[] data = ();
//可以指定字符集进行转换(推荐这样的用法)
byte[] data = line.getBytes("UTF-8");
raf.write(data);
System.out.println("写出完毕");
raf.close();
}}
/**
* 读取字符串
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 将文件中的字符读取出来
*/
RandomAccessFile raf
= new RandomAccessFile("","r");
byte[] data = new byte[(int)raf.length()];
raf.read(data);
String str = new String(data,"UTF-8");
System.out.println(str);
raf.close();
}}
/**
* RAF读写基本类型数据，以及RAF的指针操作
*//创建文件 rw，读写文件r
* @author Mr.Cui
*/
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("","rw");
long pos = raf.getFilePointer();
System.out.println("pos:"+pos);
//写入一个int最大值到文件中
int max = Integer.MAX_VALUE;
/*
* int最大值的2进制形式:
* vvvvvvvv
* 01111111 11111111 11111111 11111111
*
* max>>>24 v这里开始溢出了
* 00000000 00000000 00000000 01111111 11111111 11111111 11111111
*/
raf.write(max>>>24);
System.out.println("pos:"+raf.getFilePointer());
raf.write(max>>>16);
raf.write(max>>>8);
raf.write(max);
System.out.println("pos:"+raf.getFilePointer());
/*
* void writeInt(int d)
* 连续写出4个字节，将给定的int值写出。
* 等同上面4次write方法。
*/
raf.writeInt(max);
System.out.println("pos:"+raf.getFilePointer());
raf.writeLong(123L);
System.out.println("pos:"+raf.getFilePointer());
raf.writeDouble(123.123);
System.out.println("pos:"+raf.getFilePointer());
System.out.println("写出完毕!");
//写完后指针现在在文件末尾
//移动指针位置
raf.seek(0);//移动到文件开始位置
System.out.println("pos:"+raf.getFilePointer());
//连续读取4字节还原int值
int d = raf.readInt();
System.out.println(d);
System.out.println("pos:"+raf.getFilePointer());
//读取long
raf.seek(8);
System.out.println("pos:"+raf.getFilePointer());
long l = raf.readLong();
System.out.println(l);//123
System.out.println("pos:"+raf.getFilePointer());
double dou = raf.readDouble();
System.out.println(dou);//123.123
System.out.println("pos:"+raf.getFilePointer());
raf.close();
}}
/**
* 完成用户注册功能
*
* 程序开始后,要求用户输入:
* 用户名，密码，昵称，年龄
*
* 将该记录写入到文件中。
* 其中用户名，密码，昵称为字符串。年龄为
* 一个int值。
*
* 每条记录占用100字节，其中:用户名，密码，
* 昵称为字符串，各占32字节，年龄为int占用
* 4字节。
*
* @author
*/
public static void main(String[] args) throws IOException {
System.out.println("欢迎注册");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名:");
String username = scanner.nextLine();
System.out.println("请输入密码:");
String password = scanner.nextLine();
System.out.println("请输入昵称:");
String nickname = scanner.nextLine();
System.out.println("请输入年龄:");
int age = Integer.parseInt(scanner.nextLine());//字符串转为整型
System.out.println(username+","+password+","+nickname+","+age);
RandomAccessFile raf
= new RandomAccessFile("","rw");
//现将指针移动到文件末尾
raf.seek(raf.length());
//写用户名
//1先将用户名转成对应的一组字节
byte[] data = username.getBytes("UTF-8");
//2将该数组扩容为32字节
data = Arrays.copyOf(data, 32);
//3将该字节数组一次性写入文件
raf.write(data);
//写密码
data = password.getBytes("UTF-8");
data = Arrays.copyOf(data, 32);
raf.write(data);
//写昵称
data = nickname.getBytes("UTF-8");
data = Arrays.copyOf(data, 32);
raf.write(data);
//写年龄
raf.writeInt(age);
System.out.println("注册完毕!");
raf.close();
}}
/**
* 修改昵称
*
* 程序启动后，要求用户输入要修改昵称的用户名
* 以及新的昵称。然后将该用户昵称进行修改操作
* 若输入的用户名不存在，则提示"无此用户"。
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 1:获取用户输入的用户名及新昵称
* 2:使用RAF打开文件
* 3:循环读取每条记录
* 3.1:将指针移动到该条记录用户名
* 的位置(i*100)
* 3.2:读取32字节，将用户名读取出来
* 3.3:判断该用户是否为用户输入的用户
* 3.4:若是此人，则移动指针到该条
* 记录昵称位置，将新昵称以32字节
* 写入该位置，覆盖原昵称完成修改
* 并停止循环操作。
* 3.5:若不是此人则进入下次循环
*
* 可以添加一个开关，当修改过昵称后，改变
* 其值，最终在循环完毕后，根据开关的值判定
* 是否有修改信息来输出"无此用户"
*
*/
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名:");
String username = scanner.nextLine();
System.out.println("请输入新的昵称:");
String nickname = scanner.nextLine();
RandomAccessFile raf
= new RandomAccessFile("","rw");
//开关，表示是否有修改过信息
boolean update = false;
for(int i=0;i<raf.length()/100;i++) {
//先将指针移动到该条记录的开始位置
raf.seek(i*100);
//读取用户名
byte[] data = new byte[32];
raf.read(data);
String name = new String(data,"UTF-8").trim();
if(name.equals(username)) {
//修改昵称
//1先移动指针到昵称的位置
raf.seek(i*100+64);
//2重新写昵称32字节
data = nickname.getBytes("UTF-8");
data = Arrays.copyOf(data, 32);
raf.write(data);
System.out.println("修改完毕!");
update = true;
break;
}
}
if(!update) {
System.out.println("无此用户!");
}
raf.close();
}}
/**
* 显示所有注册用户信息
* @author
*/
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("","r");
/*
* 循环读取若干个100字节
*/
for(int i=0;i<raf.length()/100;i++) {
//读用户名
//1先读取32字节
byte[] data = new byte[32];
raf.read(data);
//2将字节数组转换为字符串
String username = new String(data,"UTF-8").trim();
//读取密码
raf.read(data);
String password = new String(data,"UTF-8").trim();
//读昵称
raf.read(data);
String nickname = new String(data,"UTF-8").trim();
//读年龄
int age = raf.readInt();
System.out.println(username+","+password+","+nickname+","+age);
}
raf.close();
}}
/**
* java IO(input,output) 输入与输出
* IO是我们的程序与外界交换数据的方式。
* java提供了一种统一的标准的方式与外界交换
* 数据。
*
* java将流按照功能划分为读和写，并用不同的方
* 向来表示
* 其中输入流(外界到程序的方向)用于读取数据
* 输出流用于写出数据。
*
* java将流划分为两大类:节点流，处理流
* 节点流:也称为低级流，是实际链接程序与数据源
* 的"管道",负责实际搬运数据。读写一定是建立在
* 节点流的基础上进行的。
*
* 处理流:也称为高级流，不能独立存在，必须链接
* 在其他流上，目的是当数据流经当前流时对这些
* 数据做某些处理，这样可以简化我们对数据的
* 操作。
*
* 实际应用中，我们是链接若干高级流，并最终链接
* 低级流，通过低级流读写数据，通过高级流对读写
* 的数据进行某些加工处理，完成一个复杂的读写
* 操作。这个过程称为"流链接"。这也是学习IO的
* 精髓所在。
*
* 文件流
* 文件流是一对低级流，用于读写文件。就功能而言
* 它们与RandomAccessFile一致。但是底层的读写
* 方式有本质区别。
* RAF是基于指针进行随机读写的，可任意读写文件指定
* 位置的数据。可以做到对文件部分数据的编辑操作。
*
* 流是顺序读写方式，所以不能做到任意读写指定
* 位置数据，对此也无法做到对文件数据进行编辑的
* 操作。但是配合高级流，可以更轻松的读写数据。
*
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 使用文件流向文件中写出字节
*
* FileOutputStream常用构造方法:
* FileOutputStream(String path)
* FileOutputStream(File file)
* 以上两种方式创建时，默认为覆盖写操
* 作，即:若创建时发现该文件已存在，会
* 先将该文件所有数据清除。然后将通过
* 当前流写出的内容作为该文件数据。
*
*
* FileOutputStream(String path,boolean append)
* FileOutputStream(File file,boolean append)
* 追加写模式，即:若指定的文件存在，那么数据全
* 保留，通过该流写出的数据会被追加到文件最后
*
*/
FileOutputStream fos
= new FileOutputStream("",true);
String line = "我们一起学猫叫，一起喵喵喵喵喵~";
byte[] data = line.getBytes("UTF-8");
fos.write(data);
System.out.println("写出完毕!");
fos.close();
}}
/**
* 使用文件输入流读取文件数据
* @author
*/
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("");
byte[] data = new byte[200];
int len = fis.read(data);
System.out.println("实际读取了:"+len+"个字节");
String str = new String(data,0,len,"UTF-8");
System.out.println(str);
fis.close();
}}
/**
* 使用文件流完成复制文件操作
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 使用文件输入流读取原文件
* 使用文件输出流向复制文件写数据
*
* 利用块读写操作顺序从原文件将数据
* 读取出来写入复制文件完成复制操作。
*/
FileInputStream src
= new FileInputStream("music.mp3");
FileOutputStream desc
= new FileOutputStream("music_cp.mp3");
int len = -1;
byte[] data = new byte[1024*10];
while((len = src.read(data))!=-1) {
desc.write(data,0,len);
}
System.out.println("复制完毕!");
src.close();
desc.close();
}}
/**
* 缓冲流BufferedInputStream
* 缓冲流是一对高级流，功能是提高读写效率。
* 链接他们以后，无论我们进行随机读写还是
* 块读写，当经过缓冲流时都会被转换为块读写
* 操作。
*
*
* @author
*/
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("music.mp3");
BufferedInputStream bis
= new BufferedInputStream(fis);
FileOutputStream fos
= new FileOutputStream("music_cp.mp3");
BufferedOutputStream bos
= new BufferedOutputStream(fos);
int d = -1;
long start = System.currentTimeMillis();
while((d = bis.read())!=-1) {
bos.write(d);
}
long end = System.currentTimeMillis();
System.out.println("复制完毕，耗时:"+(end-start)+"ms");
bis.close();
bos.close();
}}
/**
* 缓冲输出流的缓冲区问题
* @author
*/
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("");
BufferedOutputStream bos
= new BufferedOutputStream(fos);
String line = "你是隔壁的泰山，抓住爱情的藤蔓。";
byte[] data = line.getBytes("UTF-8");
/*
* 缓冲流的write方法并不是立即将数据写出，
* 而是先将数据存入其内部的数组中，当数组
* 装满时才会做一次真是写操作。(转化为块
* 写操作的过程)
*/
bos.write(data);
/*
* flush方法的意义是强制将缓冲流已经缓存的
* 数据一次性写出。这样做可以让写出的数据
* 有即时性，但是频繁调用会降低写效率。
* 在更关注写出的即时性时应当使用该方法。
*/
//();
System.out.println("写出完毕!");
/*
* close方法中会调用一次flush方法
*/
bos.close();
}}
/**
* 对象流
* 对象流也是一对高级流，提供的功能是读写java
* 中的任何对象。
*
* 对象输出流:
*
* 它可以将给定的java对象转换为一组字节然后
* 通过其连接的流将这些字节写出。
* @author
*/
public static void main(String[] args) throws IOException {
Person p = new Person();
p.setName("苍老师");
p.setAge(18);
p.setGender("女");
String[] otherInfo = {"是一名演员","爱好是写毛笔字","已婚","促进中日文化交流","广大男性同胞的启蒙老师"};
p.setOtherInfo(otherInfo);
System.out.println(p);
FileOutputStream fos
= new FileOutputStream("");
ObjectOutputStream oos
= new ObjectOutputStream(fos);
/*
* 通过对象流写出对象的这个方法经历了
* 两个步骤:
* 1:对象流先将给定的对象转换为了一组
* 字节，这组字节包含对象本身保存的
* 数据信息，还包含该对象的结构信息
* 然后将这组字节通过其连接的流写出
*
* 上述操作对应的术语:对象序列化
*
*
* 2:经过文件流时，文件流将这组字节写
* 入到了文件中
*
* 将数据写入磁盘做长久保存的过程
* 对应的术语:数据持久化
*
*
*/
oos.writeObject(p);
System.out.println("写出完毕!");
oos.close();
}}
/**
* 对象输入流
* 可以进行对象的反序列化操作。
*
* 使用对象流读取的字节必须是通过对象输出流
* 序列化的一组字节才可以。
* @author
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis
= new FileInputStream("");
ObjectInputStream ois
= new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}}
/**
* 使用当前类实例测试对象流的对象读写操作
*
* 当一个类的实例希望可以被对象流进行读写，那
* 么该类必须实现:接口
* 与此同时，当前类中所有引用类型的属性，他们
* 对应的类也必须实现该接口。
* @author
*/
public class Person implements Serializable{
/**
* 当一个类实现了Serializable接口后，要求
* 应当定义一个常量:serialVersionUID，即:
* 序列化版本号
*
* 序列化版本号影响反序列化是否成功。当对象
* 输入流在进行对象反序列化时会检查该对象与
* 当前类的版本是否一致，不一致则反序列化时
* 会抛出异常导致反序列化失败。
* 一致则可以进行反序列化，原则时对应的属性
* 进行还原。
*
* 如果我们不定义该版本号，编译器会在编译当前
* 类时根据结构生成一个版本号，但是一旦当前类
* 发生改变，那么版本号一定会改变。这样以前的
* 对象一定是不可以反序列化了。
*
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String gender;
/*
* transient关键字修饰的属性在对象序列化时
* 会被忽略。
* 忽略不必要的属性可以达到对象瘦身的作用。
*
*/
private transient String[] otherInfo;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String[] getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(String[] otherInfo) {
this.otherInfo = otherInfo;
}
public String toString() {
return name+","+age+","+gender+","+
Arrays.toString(otherInfo);
}}
/**
* 字符流
* java将流按照读写单位又进行了一种划分方式
* 字节流与字符流
* 字节流的读写单位是字节，而字符流的读写单位
* 是字符
* 所以字符流只适合读写文本数据!
*
* ,
* 这两个类也是抽象类，是所有字符输入流与
* 字符输出流的父类，规定了读写字符的相关
* 方法。
*
* 转换流
*
*
* 他们是一对常用的字符流实现类，经常在我们做
* 字符数据读写操作中使用。并且在流链接中是
* 非常重要的一个环节。但是我们很少直接对它
* 做操作。
* @author
*/
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("");
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
String line = "摩擦摩擦，在光滑的马路牙子上打出溜滑!";
osw.write(line);
line = "我的滑板鞋，时尚时尚最时尚!";
osw.write(line);
System.out.println("写出完毕!");
osw.close();
}}
/**
* 字符流
* java将流按照读写单位又进行了一种划分方式
* 字节流与字符流
* 字节流的读写单位是字节，而字符流的读写单位
* 是字符
* 所以字符流只适合读写文本数据!
*
* ,
* 这两个类也是抽象类，是所有字符输入流与
* 字符输出流的父类，规定了读写字符的相关
* 方法。
*
* 转换流
*
*
* 他们是一对常用的字符流实现类，经常在我们做
* 字符数据读写操作中使用。并且在流链接中是
* 非常重要的一个环节。但是我们很少直接对它
* 做操作。
* @author
*/
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("");
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
String line = "摩擦摩擦，在光滑的马路牙子上打出溜滑!";
osw.write(line);
line = "我的滑板鞋，时尚时尚最时尚!";
osw.write(line);
System.out.println("写出完毕!");
osw.close();
}}
/**
* 转换流
*
*
* @author
*/
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("");
InputStreamReader isr
= new InputStreamReader(fis,"UTF-8");
/*
* 字符流的方法:
* int read()
* 该方法是一次读取一个字符，实际读取
* 的字节量要根据指定的字符集决定。但
* 是当读取到该字符后在java中都是以一
* 个char形式保存(unicode)占2个字节。
*/
//int d = -1;
//while((d = ())!=-1) {
//char c = (char)d;
//(c);
//}
char[] data = new char[100];
int len = isr.read(data);
String str = new String(data,0,len);
System.out.println(str);
isr.close();
}}
/**
*
* 具有自动行刷新的缓冲字符输出流
* 开发中比较常用的字符高级流
*
* 可以按行写出字符串。
* @author
*/
public static void main(String[] args) throws IOException {
/*
* PW提供了专门针对写文件的构造方法
* PrintWriter(String path)
* PrintWriter(File file)
*/
PrintWriter pw
= new PrintWriter("","UTF-8");
pw.println("像一颗海草海草海草海草~");
pw.println("随波飘摇~");
System.out.println("写出完毕!");
pw.close();
}}
/**
* 在流链接中使用PW
* @author
*/
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("");
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw
= new BufferedWriter(osw);
PrintWriter pw
= new PrintWriter(bw);
pw.println("你好！");
System.out.println("写出完毕!");
pw.close();
}}
/**
* 完成简易记事本工具
*
* 程序启动后，要求用户输入文件名，然后对该
* 文件进行写操作。
* 之后用户输入的每一行字符串都按行写入到该
* 文件中。
* 创建PW时要求使用流链接模式。
* @author
*/
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入文件名:");
String fileName = scanner.nextLine();
FileOutputStream fos
= new FileOutputStream(fileName);
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw
= new BufferedWriter(osw);
/*
* 当在流链接当中创建PrintWriter时
* 允许指定第二个参数，该参数为一个
* boolean值，当这个值为true时，当前
* PW具有自动行刷新功能。
* 即:每当调用println方法写出一行字符串
* 时就会自动flush.
* 注意:print方法是不会自动flush的
*/
PrintWriter pw
= new PrintWriter(bw,true);
System.out.println("请开始输入内容:");
//用来记录每次用户输入的字符串
String line = null;
while(true) {
line = scanner.nextLine();
if("exit".equals(line)) {
break;
}
pw.println(line);
//();
}
System.out.println("再见!");
pw.close();
}}
/**
* 缓冲字符输入流:
*
* 特点:可以按行读取字符串
* @author
*/
public static void main(String[] args) throws IOException {
/*
* 将当前源代码输出到控制台
*/
FileInputStream fis
= new FileInputStream(
"src/io/"
);
InputStreamReader isr
= new InputStreamReader(fis);
BufferedReader br
= new BufferedReader(isr);
/*
* String readLine()
* 读取一行字符串
* 顺序读取若干字符，当读取到了换行
* 符时停止，并将换行符之前的字符组
* 成一个字符串返回。返回的字符串中
* 是不含有最有的换行符的。
* 若返回值为null，说明流读取到了
* 末尾。
*/
String line = null;
while((line = br.readLine())!=null) {
System.out.println(line);
}
br.close();
}}
/**
* 使用文件输入流读取文件数据
* @author
*/
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("");
byte[] data = new byte[200];
int len = fis.read(data);
System.out.println("实际读取了:"+len+"个字节");
String str = new String(data,0,len,"UTF-8");
System.out.println(str);
fis.close();
}}
/**
* java异常处理机制中的try-catch
* try语句块用来包含可能出错的代码片段，catch
* 用来捕获这些错误并针对该错误进行处理。
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
try {
String str = "a";
System.out.println(str.length());
System.out.println(str.charAt(0));
System.out.println(Integer.parseInt(str));
//try语句块中出错代码以下内容不执行
System.out.println("!!!!!");
}catch(NullPointerException e) {
System.out.println("出现了空指针");
}catch(StringIndexOutOfBoundsException e) {
System.out.println("字符串下标越界了!");
/*
* 应当在最后一个catch处捕获Exception
* 尽量避免一个未捕获异常导致程序中断
*/
}catch(Exception e) {
System.out.println("反正就是出了个错!");
}
System.out.println("程序结束了");
}}
/**
* finally块
* finally是异常处理机制的最后一块，可以直接
* 跟在try之后或者最后一个catch之后。
* finally可以确保只要程序运行到try语句块中
* 那么无论是否抛出异常，finally中的代码必定
* 执行。
*
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
try {
String str = null;
System.out.println(str.length());
return;
} catch (Exception e) {
System.out.println("出错了");
} finally {
System.out.println("finally!!!");
}
System.out.println("程序结束了");
}}
/**
* 在IO操作中使用异常处理机制
* @author
*/
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("");
fos.write(1);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fos!=null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}}}
/**
* JDK7之后推出了一个新特性:autoclose
* 允许编译器在编译过程中自动处理诸如流的关闭
* 工作。
* @author
*/
public static void main(String[] args) {
try(
/*
* 实现了AutoCloseable接口的类可以在
* 这里定义。编译器最终会将代码改变，
* 在finally中将其关闭
*/
FileOutputStream fos
= new FileOutputStream("");
){
fos.write(1);
} catch (IOException e) {
e.printStackTrace();
}
}}
/**
* 请分别说明:
* final finally finalize?
*
* @author
*/
public static void main(String[] args) {
System.out.println(
test("0")+","+test(null)+","+test("")
); //3,3,3
}
public static int test(String str) {
try {
System.out.println("str:"+str);
return str.charAt(0)-'0';
} catch( NullPointerException e) {
System.out.println("空指针!");
return 1;
} catch (Exception e) {
System.out.println("其他异常!");
return 2;
} finally {
return 3;
}}}
/**
* 测试异常的抛出
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
Person p = new Person();
/*
* 满足语法，但是不满足业务逻辑要求
* 这时setAge方法中可以当做异常抛出
* 要求这里调用时处理
*/
try {
/*
* 当调用一个含有throws声明异常抛出
* 的方法时，要求必须处理该异常
* 而处理方式有两种:
* 1:使用try-catch捕获并解决异常
* 2:在当前方法上继续使用throws声明
* 该异常的抛出
*/
p.setAge(10);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(p.getAge());
System.out.println("程序结束了");
}}
/**
* 使用当前类测试异常的抛出
* @author
*/
private int age;
public int getAge() {
return age;
}
/**
* 通常一个方法中使用throw抛出一个异常时
* 就要在方法声明时使用throws声明该异常的
* 抛出以通知调用者解决该异常。
* 只有抛出RuntimeException及其子类型异常
* 时可以不要求这样做。
* @param age
* @throws Exception
*/
public void setAge(int age)throws Exception {
if(age<0||age>100) {
throw new Exception("年龄不合法!");
}
this.age = age;
}}
/**
* 重写超类含有throws声明异常抛出的方法时
* 对throws的重写规则
* @author ta
*
*/
public void dosome()
throws IOException,AWTException {
}}
class Son extends ThrowsDemo{
//public void dosome()
//throws IOException,AWTException {
//}
//允许仅抛出部分异常
//public void dosome()
//throws IOException{
//}
//允许不再抛出任何异常
//public void dosome(){
//}
//允许抛出超类方法抛出异常的子类型异常
//public void dosome()
//throws FileNotFoundException {
//}
//不允许抛出额外异常
//public void dosome()
//throws SQLException {
//}
//不允许抛出超类方法抛出异常的父类型异常
//public void dosome()
//throws Exception{
//}}
package exception;
/**
* 异常常用方法
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
try {
String str = "A";
System.out.println(Integer.parseInt(str));
} catch (Exception e) {
//输出错误信息,最常用
//();
//获取错误消息
String message = e.getMessage();
System.out.println(message);
}
System.out.println("程序结束了");
}}
/**
* 年龄不合法异常
*
* 自定义异常，通常是用来说明当前项目的某个
* 业务逻辑错误。
* @author
*/
private static final long serialVersionUID = 1L;
public IllegalAgeException() {
super();
// TODO Auto-generated constructor stub
}
public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
}
public IllegalAgeException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public IllegalAgeException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public IllegalAgeException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
} }
/**
* 使用当前类测试异常的抛出
* @author
*/
private int age;
public int getAge() {
return age;
}
/**
* 通常一个方法中使用throw抛出一个异常时
* 就要在方法声明时使用throws声明该异常的
* 抛出以通知调用者解决该异常。
* 只有抛出RuntimeException及其子类型异常
* 时可以不要求这样做。
* @param age
* @throws Exception
*/
public void setAge(int age)throws IllegalAgeException {
if(age<0||age>100) {
throw new IllegalAgeException("年龄不合法!");
}
this.age = age;
} }
/**
* 测试异常的抛出
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
Person p = new Person();
/*
* 满足语法，但是不满足业务逻辑要求
* 这时setAge方法中可以当做异常抛出
* 要求这里调用时处理
*/
try {
/*
* 当调用一个含有throws声明异常抛出
* 的方法时，要求必须处理该异常
* 而处理方式有两种:
* 1:使用try-catch捕获并解决异常
* 2:在当前方法上继续使用throws声明
* 该异常的抛出
*/
p.setAge(10);
} catch (IllegalAgeException e) {
e.printStackTrace();
}
System.out.println(p.getAge());
System.out.println("程序结束了");
}}
/**
* 线程是并发运行代码的。
* 有两种创建线程的方式:
* 方式一，继承Thread并重写run方法。run方法中
* 就是希望线程执行的逻辑。
* @author ta
*
*/
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t1 = new MyThread1();
Thread t2 = new MyThread2();
/*
* 启动线程要调用start方法，而不是
* 直接调用run方法。当start方法调用
* 完毕后，run方法很快会被线程自行调
* 用。
*/
t1.start();
t2.start();
}
}
/**
* 第一种创建线程的方式比较简单直接，但是缺点
* 主要有两个:
* 1:由于需要继承线程，这导致不能再继承其他类
* 实际开发中经常要复用某个超类的功能，那么
* 在继承线程后不能再继承其他类会有很多不便
*
* 2:定义线程类的同时重写了run方法，这会导致
* 线程与线程要执行的任务有一个必然的耦合
* 关系，不利于线程的重用。
* @author
*/
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("你是谁啊?");
}
}}
class MyThread2 extends Thread{
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("我是查水表的!");
}
}}
/**
* 第二种创建线程的方式
* 实现Runnable接口，单独定义线程任务
* @author
*/
public static void main(String[] args) {
//实例化两个任务
Runnable r1 = new MyRunnable1();
Runnable r2 = new MyRunnable2();
//创建两个线程并指派任务
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}}
class MyRunnable1 implements Runnable{
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("你是谁啊?");
}
}}
class MyRunnable2 implements Runnable{
public void run() {
for(int i=0;i<1000;i++) {
System.out.println("我是查水表的!");
}
}}
/**
* 线程提供了获取相关信息的方法
* @author
*/
public static void main(String[] args) {
/*
* 线程提供了一个静态方法:
* static Thread currentThread()
* 该方法用来获取运行这个方法的线程
* main方法也是靠一个线程运行的，当JVM启动
* 后会自动创建一个线程来执行main方法。而
* 这个线程的名字叫做"main",我们称它为主线程
*
* 获取运行main方法的线程
*
*/
Thread main = Thread.currentThread();
System.out.println("运行main方法的线程:"+main);
dosome();
Thread t = new Thread() {
public void run() {
Thread t = Thread.currentThread();
System.out.println("自定义线程:"+t);
dosome();
}
};
t.start();
}
public static void dosome() {
Thread t = Thread.currentThread();
System.out.println("运行dosome方法的线程是:"+t);
}}
/**
* 线程提供了获去自身信息的相关方法
* @author
*/
public static void main(String[] args) {
Thread main = Thread.currentThread();
//获去线程的名字
String name = main.getName();
System.out.println("name:"+name);
//获去线程的唯一标识(id)
long id = main.getId();
System.out.println("id:"+id);
//获去线程的优先级
int priority = main.getPriority();
System.out.println("优先级:"+priority);
//线程是否还处于活动状态
boolean isAlive = main.isAlive();
System.out.println("isAlive:"+isAlive);
//线程是否是被中断了
boolean isInterrupted = main.isInterrupted();
System.out.println("isInterrupted:"+isInterrupted);
//线程是否为守护线程
boolean isDaemon = main.isDaemon();
System.out.println("isDaemon:"+isDaemon);
}}
/**
* 线程的优先级
* 线程不能主动获去CPU时间片，只能被动的被
* 线程调度器分配。
* 调整线程的优先级可以最大程度的改善某个线程
* 获去CPU时间片的次数。
* 理论上线程优先级约高的线程获去CPU时间片的
* 次数就越多。
* @author
*/
public static void main(String[] args) {
Thread max = new Thread() {
public void run() {
for(int i=0;i<10000;i++) {
System.out.println("max");
}
}
};
Thread min = new Thread() {
public void run() {
for(int i=0;i<10000;i++) {
System.out.println("min");
}
}
};
Thread norm = new Thread() {
public void run() {
for(int i=0;i<10000;i++) {
System.out.println("nor");
}
}
};
max.setPriority(Thread.MAX_PRIORITY);
min.setPriority(Thread.MIN_PRIORITY);
min.start();
norm.start();
max.start();
}}
/**
* 线程提供了一个静态方法:
* static void sleep(long ms)
* 使运行这个方法的线程阻塞指定毫秒。超时后
* 该线程会自动回到RUNNABLE状态，等待再次并发
* 运行。
* @author
*/
public static void main(String[] args) {
System.out.println("程序开始了");
while(true) {
System.out.println("你好!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}}}
/**
* 倒计时程序
* 程序启动后，要求输入一个数字，比如:100
* 然后每秒输出一次，每次输出数字递减。
* 输出到0时提示结束，程序退出。
* @author
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数字:");
String line = scanner.nextLine();
Integer num = Integer.parseInt(line);
for(;num>0;num--) {
System.out.println(num);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("结束!");
}}
/**
* sleep方法要求必须处理中断异常，原因在于当
* 一个线程调用了sleep方法处于阻塞状态的过程
* 中若被调用了它的interrupt()方法中断时，它
* 就会在sleep方法中抛出中断异常。这时并非是
* 将这个线程直接中断，而是中断了它的阻塞状态
* @author
*
*/
public static void main(String[] args) {
/*
* JDK8之前，由于JVM内存分配问题，有一个
* 要求:
* 当一个方法的局部变量被这个方法的其他
* 局部内部类所引用是，这个变量声明必须
* 是final的。
*/
final Thread lin = new Thread() {
public void run() {
System.out.println("林:刚美完容，睡一会吧!");
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
System.out.println("林:干嘛呢!干嘛呢!干嘛呢!都破了相了!");
}
System.out.println("林:醒了!");
}
};
Thread huang = new Thread() {
public void run() {
System.out.println("黄:开始砸墙!");
for(int i=0;i<5;i++) {
System.out.println("黄:80!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
System.out.println("咣当!");
System.out.println("黄:搞定!");
//中断lin线程
lin.interrupt();
}
};
lin.start();
huang.start();
}}
/**
* 守护线程
* 守护线程又称为后台线程，默认创建的线程都
* 是普通线程或称为前台线程，线程提供了一个
* 方法:
* void setDaemon(boolean on)
* 只有调用该方法并传入参数true时，该线程才
* 会被设置为守护线程。
*
*
* 守护线程在使用上与普通线程没有差别，但是在
* 结束时机上有一个区别，即:线程结束时所有正在
* 运行的守护线程都会被强制停止。
*
* 线程的结束:当一个进程中所有的普通线程都结束
* 时，进程即结束。
*
* @author
*
*/
public static void main(String[] args) {
Thread rose = new Thread() {
public void run() {
for(int i=0;i<5;i++) {
System.out.println("rose:let me go!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
System.out.println("rose:啊啊啊啊啊AAAAAAAaaaaaa.....");
System.out.println("噗通!");
}
};
Thread jack = new Thread() {
public void run() {
while(true) {
System.out.println("jack:you jump!i jump!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
};
rose.start();
/*
* 设置为守护线程
* 注意，必须在线程启动前进行设置
*/
jack.setDaemon(true);
jack.start();
}}
/**
* 线程提供了一个方法:
* void join()
* 该方法可以协调线程之间的同步运行
*
* 同步与异步:
* 同步运行:运行有顺序
* 异步运行:运行代码无顺序，多线程并发运行就
* 是异步运行
* @author
*
*/
//标识图片是否下载完毕
private static boolean isFinish = false;
public static void main(String[] args) {
Thread download = new Thread() {
public void run() {
System.out.println("down:开始下载图片...");
for(int i=1;i<=100;i++) {
System.out.println("down:"+i+"%");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
}
}
System.out.println("down:下载图片完毕!");
isFinish = true;
}
};
Thread show = new Thread() {
public void run() {
System.out.println("show:开始显示图片");
//加载图片前应先等待下载线程将图片下载完毕
try {
/*
* show线程在调用()方法后
* 就进入了阻塞状态，直到download线程
* 的run方法执行完毕才会解除阻塞
*/
download.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
if(!isFinish) {
throw new RuntimeException("加载图片失败!");
}
System.out.println("show:显示图片完毕!");
}
};
download.start();
show.start();
}}
/**
* 同步块
* 语法:
* synchronized(同步监视器对象){
* 需要同步运行的代码片段
* }
*
* 同步块可以更精确的控制需要同步运行的代码
* 片段。有效的缩小同步范围可以在保证并发安全
* 的前提下提高代码并发运行的效率
* 使用同步块控制多线程同步运行必须要求这些
* 线程看到的同步监视器对象为[同一个]。
*
* @author
*
*/
public static void main(String[] args) {
Shop shop = new Shop();
Thread t1 = new Thread() {
public void run() {
shop.buy();
}
};
Thread t2 = new Thread() {
public void run() {
shop.buy();
}
};
t1.start();
t2.start();
}
}
class Shop{
// public synchronized void buy() {
public void buy() {
try {
Thread t = Thread.currentThread();
System.out.println(t.getName()+":正在挑衣服...");
Thread.sleep(5000);
synchronized (this) {
System.out.println(t.getName()+":正在试衣服...");
Thread.sleep(5000);
}
System.out.println(t.getName()+":结账离开");
} catch (Exception e) {
}
}}
/**
* 多线程并发的安全问题。
* 产生:当多个线程并发操作同一资源时，由于线程
* 切换实际的不确定性，会导致执行操作资源的代码
* 顺序未按照设计顺序执行，出现操作混乱的情况。
* 严重时可能导致系统瘫痪。
*
* 解决:将并发操作同一资源改为同步操作，即:有
* 先后顺序的操作。
* @author
*
*/
public static void main(String[] args) {
Table table = new Table();
Thread t1 = new Thread() {
public void run() {
while(true) {
int bean = table.getBean();
Thread.yield();
System.out.println(getName()+":"+bean);
}
}
};
Thread t2 = new Thread() {
public void run() {
while(true) {
int bean = table.getBean();
Thread.yield();
System.out.println(getName()+":"+bean);
}
}
};
t1.start();
t2.start();
}
}
class Table{
//20个豆子
private int beans = 20;
/**
* 当一个方法被synchronized修饰后，该方法
* 称为"同步方法",即:多个线程不能同时在方
* 法内部运行。强制让多个线程在执行同一个
* 方法时变为同步操作就解决了并发安全问题
*
* 在方法上使用synchronized，那么同步监视器
* 对象就是当前方法所属对象，即:方法内部看到
* 的this
* @return
*/
public synchronized int getBean() {
if(beans==0) {
throw new RuntimeException("没有豆子了!");
}
//模拟线程执行到这里没有时间了
Thread.yield();
return beans--;
}
}
/**
* 静态方法若使用synchroinzed修饰，那么该方法
* 一定具有同步效果
* 静态方法对应的同步监视器对象为当前类的
* 类对象(Class的实例)。类对象会在后面反射
* 的课程中讲到。
* @author
*/
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
Foo.dosome();
}
};
Thread t2 = new Thread() {
public void run() {
Foo.dosome();
}
};
t1.start();
t2.start();
}
}
class Foo{
public synchronized static void dosome() {
Thread t = Thread.currentThread();
System.out.println(t.getName()+":正在运行dosome方法");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t.getName()+":运行dosome方法完毕");
}}
/**
* 互斥锁
* 当多个代码片段被synchronized块修饰后，这些
* 同步块的同步监听器对象又是同一个时，这些
* 代码片段就是互斥的。多个线程不能同时在这些
* 方法中运行。
* @author
*
*/
public static void main(String[] args) {
Boo boo = new Boo();
Thread t1 = new Thread() {
public void run() {
boo.methodA();
}
};
Thread t2 = new Thread() {
public void run() {
boo.methodB();
}
};
t1.start();
t2.start();
}
}
class Boo{
public synchronized void methodA() {
Thread t = Thread.currentThread();
try {
System.out.println(t.getName()+":正在运行A方法");
Thread.sleep(5000);
System.out.println(t.getName()+":运行A方法完毕");
} catch (Exception e) {
}
}
public void methodB() {
synchronized (this) {
Thread t = Thread.currentThread();
try {
System.out.println(t.getName()+":正在运行B方法");
Thread.sleep(5000);
System.out.println(t.getName()+":运行B方法完毕");
} catch (Exception e) {
}
}} }
/**
*
* 集合
* 集合与数组相似，可以保存一组元素，并且提供
* 了操作集合元素的相关方法，使用便捷。
* Collection接口下面有两个常见的子接口:
* :可重复集合，并且有序，可以
* 通过下标操作元素。
*
* :不可重复集合。
* 元素是否重复是依靠元素自身equals比较进行
* 判定的.
* @author
*
*/
public static void main(String[] args) {
Collection c = new ArrayList();
/*
* boolean add(E e)
* 向当前集合中添加给定元素，当该元素
* 成功添加则返回true。
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
/*
* int size()
* 返回当前集合的元素个数
*/
int size = c.size();
System.out.println("size:"+size);
/*
* boolean isEmpty()
* 判断当前集合是否为空集(不含有任何
* 元素)
*/
boolean isEmpty = c.isEmpty();
System.out.println("isEmpty:"+isEmpty);
/*
* void clear()
* 清空当前集合
*/
c.clear();
System.out.println("集合已清空");
System.out.println(c);
System.out.println("size:"+c.size());
System.out.println("isEmpty:"+c.isEmpty());
}}
/**
* 集合提供了判断是否包含给定元素的方法:
* boolean contains(E e)
*
* @author
*
*/
public class ContainsDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(9,0));
/*
* 集合的toString方法会将每个元素
* 的toString体现出来。
*/
System.out.println(c);
Point p = new Point(1,2);
// (p);
/*
* contains方法是依靠元素自身equals比较
* 的结果判别集合是否包含该元素
*/
boolean contains = c.contains(p);
System.out.println("包含:"+contains);
}}
/**
* 集合只能存放引用类型元素，并且存放的也是元
* 素的引用(地址)
* @author
*
*/
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1,2);
c.add(p);
System.out.println("c:"+c);
System.out.println("p:"+p);
p.setX(2);
System.out.println("c:"+c);//[(2,2)]
System.out.println("p:"+p);//(2,2)
}}
___________________________________________________________________{
public class Test {
public static void main(String[] args) {
int a = 1;
String b = "hello";
Point p = new Point(1,2);
Collection c = new ArrayList();
c.add(p);
test(a, b, p, c);
System.out.println("a:"+a);//?
System.out.println("b:"+b);//?
System.out.println("p:"+p);//?
System.out.println("c:"+c);//?
}
public static void test(int a,String b,Point p,Collection c){
a = 2;
b = b+"world";
p.setX(3);
p = new Point(5,6);
c.clear();
c.add(p);
p.setY(7);
c = new ArrayList();
c.add(p);
}
}
/**
* 使用当前类实例作为集合元素，测试集合相关
* 操作。
* @author
*
*/
public class Point {
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String toString() {
return "("+x+","+y+")";
}
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(obj == this) {
return true;
}
if(obj instanceof Point) {
Point p = (Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}}
/**
* 删除集合元素
* @author
*/
public class RemoveDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(9,0));
c.add(new Point(1,2));
System.out.println(c);
Point p = new Point(1,2);
/*
* 删除元素也是依靠元素equals比较判定
*/
c.remove(p);
System.out.println(c);
}}
/**
* 集合操作
* @author
*
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("java");
c1.add("c");
c1.add("c++");
System.out.println("c1:"+c1);
Collection c2 = new HashSet();
c2.add("php");
c2.add(".net");
c2.add("java");
System.out.println("c2:"+c2);
/*
* boolean addAll(Collection c)
* 将给定集合中的所有元素添加到
* 当前集合中。
*/
c2.addAll(c1);
System.out.println("c2:"+c2);
Collection c3 = new ArrayList();
c3.add("c");
c3.add(".net");
c3.add("android");
System.out.println("c3:"+c3);
/*
* boolean containsAll(Collection c)
* 判断当前集合是否包含给定集合中的
* 所有元素
*/
boolean ca = c2.containsAll(c3);
System.out.println("全包含:"+ca);
/*
* 删除当前集合与给定集合的共有元素
*/
c2.removeAll(c3);
System.out.println(c2);
}}
/**
* 集合提供了同一的遍历元素方式:迭代器模式
*
* 对应方法:
* Iterator iterator()
* 该方法可以获取一个用来遍历当前集合的迭代器
* 实现类，通过它遍历元素
*
* 接口
* 迭代器接口，规定了迭代器遍历集合的相关操作
* 不同的集合都实现了一个用于遍历自身元素的
* 迭代器实现类。
*
* 迭代器遍历集合元素遵循的过程:问，取，删
* 其中删除元素不是必要操作
*
* @author
*
*/
public class IteratorDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
c.add("#");
c.add("five");
System.out.println(c);
//获取迭代器
Iterator it = c.iterator();
/*
* boolean hasNext()
* 判断集合是否还有元素可以迭代
*/
while(it.hasNext()) {//问
/*
* E next()
* 迭代集合下一个元素
*/
String o = (String)it.next();//取
if("#".equals(o)) {
// (o);
/*
* 删除的是通过next方法取出
* 的元素
*/
it.remove();//删
}
System.out.println(o);
}
System.out.println(c);
}}
——————————————————————————————}
/**
* JDK5推出时，推出了一个新的特性:
* 增强型for循环，也称为新循环，for each
*
* 新循环不取代传统for循环的工作，它专门设计
* 是用来遍历集合或数组的。
*
* @author
*/
public static void main(String[] args) {
String[] array = {"one","two","three","four"};
for(int i=0;i<array.length;i++) {
System.out.println(array[i]);
}
/*
* 新循环的语法也是编译器认可，而非虚拟机
* 认可。编译器会在编译源代码时将新循环
* 遍历数组改为传统for循环遍历的方式
*/
for(String str : array) {
System.out.println(str);
}
}}
/**
* 使用新循环遍历集合
* @author
*/
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
/*
* 新循环遍历集合会被编译器改为使用
* 迭代器遍历。所以在遍历的过程中是
* 不能通过集合的方法增删元素的。
*/
for(Object o : c) {
String str = (String)o;
System.out.println(str);
}
}}
/**
* 泛型
* 泛型是JDK5推出的特性， 也称为参数化类型
* 它允许将一个类中属性的类型，方法参数的类型
* 以及方法返回值类型等的定义权移交给使用者。
* 这使得实际应用中使用这个类更加灵活便捷。
* @author
*/
public class Location<E> {
private E x;
private E y;
public Location(E x, E y) {
super();
this.x = x;
this.y = y;
}
public E getX() {
return x;
}
public void setX(E x) {
this.x = x;
}
public E getY() {
return y;
}
public void setY(E y) {
this.y = y;
}
@Override
public String toString() {
return "("+x+","+y+")";
}}
/**
* 测试泛型
* @author
*/
public class TypeDemo {
public static void main(String[] args) {
Location<Integer> loc1 = new Location<Integer>(1,2);
loc1.setX(2);
int x1 = loc1.getX();
System.out.println("loc1:"+loc1);
System.out.println("x1:"+x1);
Location<Double> loc2 = new Location<Double>(1.1,2.2);
loc2.setX(2.2);
double x2 = loc2.getX();
System.out.println("loc2:"+loc2);
System.out.println("x2:"+x2);
Location<String> loc3 = new Location<String>("一","二 ");
loc3.setX("三");
String x3 = loc3.getX();
}}
**
* 泛型是编译器认可，而非虚拟机。
* 编译器会将泛型改为Object。所以泛型的实际
* 类型就是Object
* 在使用泛型时，编译器会辅助做两个操作
* 1:对泛型设置值时，编译器会检查该值的类型
* 是否与泛型一致，不一致则编译不通过。
* 2:在获取泛型值时，编译器会添加向下造型的
* 代码。
* @author Mr.Cui
*/
public static void main(String[] args) {
Location<Integer> loc1 = new Location<Integer>(1,2);
/*
* 编译器会检查实际赋值是否符合泛型类型
* 要求，不符合编译不通过。
*/
loc1.setX(1);
// ("1");//编译不通过
/*
* 编译器会在编译时补全向下造型的代码为:
* int x1 = (Integer)();
* 然后还会触发自动拆箱，改为
* int x1 = ((Integer)()).intValue();
*/
int x1 = loc1.getX();
System.out.println("loc1:"+loc1);
System.out.println("x1:"+x1);
/*
* 泛型可以不指定，不指定则按照默认的
* Object看待
*/
Location loc2 = loc1;
System.out.println("loc2:"+loc2);
loc2.setX("三");
System.out.println("loc2:"+loc2);
//再次以loc1角度获取x
//x1 = (Integer)();
x1 = loc1.getX();//类造型异常
System.out.println("x1:"+x1);
}}
/**
* 泛型在集合当中的应用---约束集合中的元素类型
* @author
*/
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
/*
* 指定后add方法只能传入泛型要求的
* 元素
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
/*
* 新循环可以直接用实际类型接收元素
*/
for(String str: c) {
System.out.println(str);
}
/*
* 迭代器也支持泛型，指定的类型与
* 集合的泛型一致即可
*/
Iterator<String> it = c.iterator();
while(it.hasNext()) {
String str = it.next();
System.out.println(str);
}
}}
/**
* 接口
* List继承自Collection
* List的特点:可重复，并且有序，提供了一组可以
* 通过下标操作元素的方法。
*
* 常用实现类:
* :内部由数组实现，查询
* 性能更好。
* :内部由链表实现，增删
* 元素性能更好，尤其首尾增删元素。
* 在对性能没有特别苛刻要求下，通常使用的是
* ArrayList即可。
*
* @author
*/
public static void main(String[] args) {
List<String> list
= new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println(list);
/*
* E get(int index)
* 获取给定下标对应的元素
*/
String str = list.get(1);
System.out.println(str);
//List可以用普通的for循环遍历
for(int i=0;i<list.size();i++) {
str = list.get(i);
System.out.println(str);
}
/*
* E set(int index, E e)
* 将给定元素设置到指定位置，返回值为
* 原位置对应元素。所以set方法的意义是
* 替换元素操作
*/
//[one,2,three,four,five]
String old = list.set(1, "2");
System.out.println(list);
System.out.println(old);
}}
/**
* List提供了一对重载的add,remove方法
* @author
*/
public static void main(String[] args) {
List<String> list
= new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println(list);
/*
* void add(int index,E e)
* 将给定元素插入到指定位置
*
* [one,2,two,three,four,five]
*/
list.add(1, "2");
System.out.println(list);
/*
* E remove(int index)
* 删除并返回给定位置对应的元素
* [one,2,three,four,five]
*/
String old = list.remove(2);
System.out.println(list);
System.out.println(old);
}}
/**
* 使用当前类实例作为集合元素，测试集合相关
* 操作。
* @author
*/
public class Point
implements Comparable<Point>{
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String toString() {
return "("+x+","+y+")";
}
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(obj == this) {
return true;
}
if(obj instanceof Point) {
Point p = (Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}
/**
* 当一个类实现了Comparable接口后必须重写
* 方法：compareTo
* 该方法的作用是比较当前对象this与方法的
* 参数对象o之间的大小。
*
* 返回值不关心具体取值，只关心取值范围
* 当返回值>0:当前对象大于参数对象(this>o)
* 当返回值<0:当前对象小于参数对象
* 当返回值=0:两个对象相等
*/
public int compareTo(Point o) {
int len = this.x*this.x+this.y*this.y;
int olen = o.x*o.x+o.y*o.y;
return len-olen;
}
}
/**
* 获取子集操作
* List subLis(int start,int end)
* 获取当前集合指定下标对应范围内的元素
* @author
*/
public static void main(String[] args) {
List<Integer> list
= new ArrayList<Integer>();
for(int i=0;i<10;i++) {
list.add(i);
}
System.out.println(list);
List<Integer> subList = list.subList(3, 8);
System.out.println(subList);
/*
* 将子集每个元素扩大10倍
*/
for(int i=0;i<subList.size();i++) {
subList.set(i,subList.get(i)*10);
}
System.out.println(subList);
/*
* 操作子集就是对原集合对应元素的操作
*/
System.out.println(list);
/*
* 将list集合中2-8删除
*/
list.subList(2, 9).clear();
System.out.println(list);
}}
/**
* 集合转换为数组
* 集合提供了一个方法:toArray，可以将当前
* 集合转换为一个数组
* @author
*/
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
// Object[] array = ();
String[] array
= c.toArray(new String[c.size()]);
System.out.println(array.length);
System.out.println(Arrays.toString(array));
}}
/**
* 数组转换为List集合。
* 通过数组的工具类:Arrays的静态方法asList
* 可以将一个数组转换为一个List
*
* @author
*/
public static void main(String[] args) {
String[] array = {"one","two","three","four"};
List<String> list
= Arrays.asList(array);
System.out.println(list);
/*
* 数组转换的集合对其元素操作就是对
* 原数组对应元素的操作
*/
list.set(1, "2");
System.out.println(list);
System.out.println("array:"+Arrays.toString(array));
/*
* 由于数组是定长的，所以不支持集合
* 的增删操作，下面的操作会抛出异常
*/
// ("five");
/*
* 所有的集合都提供了一个参数为Collection
* 的构造方法，作用是在创建当前集合的同时
* 包含给定集合中的所有元素
*/
List<String> list2
= new ArrayList<String>(list);
list2.add("five");
System.out.println(list2);
}}
/**
* 集合工具类:
* 其提供了一个静态方法：sort，可以对List集合
* 进行自然排序(从小到大)
* @author
*/
public static void main(String[] args) {
List<Integer> list
= new ArrayList<Integer>();
Random random = new Random();
for(int i=0;i<10;i++) {
list.add(random.nextInt(100));
}
System.out.println(list);
Collections.sort(list);
System.out.println(list);
}}
/**
* 排序自定义类型元素
* @author
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<Point> list = new ArrayList<Point>();
list.add(new Point(3,4));
list.add(new Point(4,9));
list.add(new Point(2,7));
list.add(new Point(8,1));
list.add(new Point(6,0));
list.add(new Point(4,4));
System.out.println(list);
/*
* Collections的sort方法排序的集合要求
* 元素必须实现Comparable接口。
*/
Collections.sort(list);
System.out.println(list);
}}
/**
* 创建一个List集合，并存放10个随机数，然后排序该集合
* 后输出
* @author
*/
public static void main(String[] args){
List<Integer> l = new ArrayList<Integer>();
Random random = new Random();
for(int a =0; a<10;a++){
l.add(random.nextInt(100));
}
System.out.println("10个"+"随机数:"+l);
Collections.sort(l);
System.out.println("排序后为:"+
l);
}}
/**
* 使用当前类实例作为集合元素，测试集合相关
* 操作。
*
* 侵入性
* @author
*/
public class Point
implements Comparable<Point>{
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String toString() {
return "("+x+","+y+")";
}
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(obj == this) {
return true;
}
if(obj instanceof Point) {
Point p = (Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}
/**
* 当一个类实现了Comparable接口后必须重写
* 方法：compareTo
* 该方法的作用是比较当前对象this与方法的
* 参数对象o之间的大小。
*
* 返回值不关心具体取值，只关心取值范围
* 当返回值>0:当前对象大于参数对象(this>o)
* 当返回值<0:当前对象小于参数对象
* 当返回值=0:两个对象相等
*/
public int compareTo(Point o) {
int len = this.x*this.x+this.y*this.y;
int olen = o.x*o.x+o.y*o.y;
return len-olen;
}}
/**
* 排序自定义类型元素
* @author
*/
public static void main(String[] args) {
List<Point> list = new ArrayList<Point>();
list.add(new Point(3,4));
list.add(new Point(4,9));
list.add(new Point(2,7));
list.add(new Point(8,1));
list.add(new Point(6,0));
list.add(new Point(4,4));
System.out.println(list);
/*
* Collections的sort方法排序的集合要求
* 元素必须实现Comparable接口。
*
* 如果是排序自定义类型元素，强烈建议
* 不使用这种方式，因为这个sort方法对
* 我们的代码有侵入性(它要求Point必须
* 为它实现接口，并重写方法)
* 由于java API中很多类已经实现了该接口，
* 比如包装类，String等，那么在排序这
* 样元素的集合时可以直接用下面这个sort
*/
//排序.sort (list);
System.out.println(list);
}}
/**
* 排序字符串
* @author
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("小泽老师");
list.add("传奇");
list.add("苍老师");
System.out.println(list);
/*
* String已经实现了Comparable接口
* 比较规则为按照每个字符的unicode编码
* 比较。
* 对于排序中文时，没有什么意义。
*
* 对此，该sort方法的使用相对局限。
* 所以当:
* 排序自定义类型元素或java提供的已经实现
* 过Comparable接口的元素，但是比较方法不
* 满足我们排序需求时，都不应当使用下面的
* sort方法
*
*/
Collections.sort(list);
System.out.println(list);
}}
/**
* Collections提供了一个重载的sort方法，该
* 方法除了要求传入要排序的集合外，还要求再
* 传入一个比较器(Comparator),该比较器可以
* 定义一种比较规则，该sort方法会用这个比较
* 规则对集合元素比较后进行排序。
*
* @author
*/
public class SortListDemo4 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("传奇");
list.add("小泽老师");
list.add("苍老师");
System.out.println(list);
/*
* 这种排序方法不要求集合元素必须实现Comparable
* 接口，对此在排序自定义元素时不对我们的代码
* 产生额外侵入，由于可以自定比较规则，对于像
* String这样已经实现类比较方法的可以做到按照
* 我们的比较规则排序。
* 开发中推荐中这种方式排序.
*/
Collections.sort(
list,new Comparator<String>() {
public int compare(String o1, String o2){
//按照字符多少比大小
return o1.length()-o2.length();
}
});
System.out.println(list);
}}
/**
*
* Queue接口继承自Collection。
* 队列也可以保存一组元素，但是存取元素必须
* 遵循先进先出模式。
* 常用实现类:LinkedList
* @author
*/
public class QueueDemo {
public static void main(String[] args) {
Queue<String> queue
= new LinkedList<String>();
/*
* offer是入队操作，向队列末尾追加
* 元素
*/
queue.offer("one");
queue.offer("two");
queue.offer("three");
queue.offer("four");
queue.offer("five");
queue.offer("six");
System.out.println(queue);
/*
* poll方法是出队操作
* 获取队首元素后该元素即从队列中
* 被删除
*/
String str = queue.poll();
System.out.println(str);
System.out.println(queue);
/*
* peek是引用队首元素，元素不做出队
* 操作
*/
str = queue.peek();
System.out.println(str);
System.out.println(queue);
/*
* 遍历队列
* 使用迭代器遍历，元素不会因此被队列
* 删除
*
*/
for(String s : queue) {
System.out.println(s);
}
System.out.println(queue);
/*
* 使用poll方法遍历队列
*/
while(queue.size()>0) {
String s = queue.poll();
System.out.println(s);
}
System.out.println(queue);
}}
/**
* 双端队列
* 接口
* Deque继承自Queue接口
* 双端队列是指队列两端都可以做进出队操作。
* 常用实现类:LinkedList
* @author
*/
public class DequeDemo {
public static void main(String[] args) {
Deque<String> deque
= new LinkedList<String>();
deque.offer("one");
deque.offer("two");
// First 开始位置
deque.offerFirst("three");
//Last 末端位置
deque.offerLast("four");
System.out.println(deque);
String str = deque.poll(); //出队操作
System.out.println(str);
System.out.println(deque);
//从开头开始删除
str = deque.pollFirst();
System.out.println(str);
System.out.println(deque);
//从末端开始删除
str = deque.pollLast();
System.out.println(str);
System.out.println(deque);
}}
/**
* 栈结构
* 栈也可以保存一组元素，但是存取元素必须遵循
* 先进后出原则。
* Deque双端队列可以实现栈，并且为栈专门提供
* 了两个方法:push,pop
* 通常我们使用栈是为了实现"后退"这样等功能
* @author
*
*/
public class StackDemo {
public static void main(String[] args) {
Deque<String> stack
= new LinkedList<String>();
//stack 后退输出 如123输出321
stack.push("one");
stack.push("two");
stack.push("three");
stack.push("four");
stack.push("five");
System.out.println(stack);
//remove,poll,pop,均表示删除
String str = stack.pop();
System.out.println(str);//删除元素
System.out.println(stack);//输出删除后的元素
}}
/**
* 集合有线程安全的实现。我们可以借助Collections
* 将现有的集合转换为一个线程安全的。
* @author
*
*/
public class SyncDemo {
public static void main(String[] args) {
/*
* List中常用的实现类:
* ArrayList,LinkedList它们都不是
* 线程安全的。
*/
List<String> list
= new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
System.out.println(list);
/*
* 将给定的集合转换为一个线程安全的
*/
list = Collections.synchronizedList(list);
System.out.println(list);
/*
* HashSet同样也不是线程安全的
*/
Set<String> set
= new HashSet<String>(list);
set = Collections.synchronizedSet(set);
System.out.println(set);
/*
* 文档上有说明一个事情:
* 即使是一个线程安全的集合，它也不同
* 迭代器遍历做互斥，所以这个操作要自行
* 维护。
*/
/*
* 队列也有并发安全的实现
* 阻塞队列
* BlockingQueue,BlockingDeque
* 阻塞队列内部使用双缓冲实现，在保证
* 并发安全的前提下解决了存取互斥问题
* 所以并发效率更好
*/
BlockingQueue<String> queue
= new LinkedBlockingQueue<String>();
queue.offer("one");
try {
//500是时间(毫秒)，是单位
queue.offer("two", 500, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}}
/**
* 判断Map是否包含给定元素。
* 可以分别判断是否包含key和value
* boolean containsKey(Object k)
* boolean containsValue(Object v)
* @author
*/
public static void main(String[] args) {
Map<String,Integer> map
= new HashMap<String,Integer>();
map.put("语文", 98);
map.put("数学", 97);
map.put("英语", 96);
map.put("物理", 95);
map.put("化学", 98);
System.out.println(map);
/*
* 查看是否包含指定的key
*/
boolean ck = map.containsKey("语文");
System.out.println("包含key:"+ck);
boolean cv = map.containsValue(95);
System.out.println("包含value:"+cv);
}}
/**
* HashMap是查询速度最快的数据结构，内部使用
* 数组实现，它通过Key的hashcode值计算该元素
* 在数组中的下标位置，从而避免了遍历数组的操
* 作，从而查询不受元素多少影响。
*
* 由于Key的hashcode方法(决定其在HashMap内部
* 数组的位置)和equals方法(决定Key是否为重复)
* 直接影响HashMap是否会出现链表，对此这两个
* 方法在Object类中有明确的重写说明。
*
* 当一个HashMap内部出现链表时，会降低其查询
* 性能，应当尽量避免。而出现链表的情况在于:
* 当两个Key的hashcode值相同，而equals比较不
* 为true时就会形成。
*
* API手册中在Object类里说明了这两个方法的重
* 写规则:
* 1:成对重写
* 当我们需要重写一个类的equals方法时，就
* 应当连同重写hashcode方法
* 2:一致性
* 当两个对象的equals比较为true时，hashcode
* 方法返回的数字必须相等。反之则不是必须的，
* 但是应当尽量保证当两个对象hashcode值相同
* 时equals方法比较为true，否则在HashMap中
* 作为Key使用时会出现链表!
* 3:稳定性
* 当一个对象参与equals比较的属性值没有发生
* 过改变的前提下，多次调用hashcode方法返回
* 的数字应当相同
*
* @author
*
*/
public class Key {
private int x;
private int y;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Key other = (Key) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
} }
/**
*
* Map 查找表，结构看起来像是一个多行两列的
* 表格。左列称为key，右列称为value。
* 所以Map总是以key-value对的形式保存元素。
* 并且总是根据key去获取对应的value.
* 对此我们经常将“查询条件”作为key，将要查询
* 的数据作为value进行保存。
*
* Map本身是一个接口，规定了Map操作的相关方法。
* 常用实现类:
*
* HashMap又称为散列表，哈希表
* 使用散列算法实现的Map，当今世界上查询速度
* 最快的数据结构，查询速度最快，查询速度最快！
*
* @author
*/
public class MapDemo1 {
public static void main(String[] args) {
Map<String,Integer> map
= new HashMap<String,Integer>();
/*
* V put(K k,V v)
* 将给定的一组键值对存入到Map中
*
* Map有一个要求，即:key不允许重复，
* 是否重复是依靠key自身equals比较的
* 结果。
* 如果使用map中已有的key保存value,
* 则这个操作为替换value操作，那么
* 这时put方法会将被替换的value返回。
* 否则返回值为null。
*/
/*
* 如果value是一个包装类，那么接收时
* 应当避免直接用基本类型。因为这会
* 导致自动拆箱，若没有做替换操作，返
* 回的value为null时就引发了空指针异常
*/
Integer d = map.put("语文", 98);
System.out.println(d);
map.put("数学", 97);
map.put("英语", 96);
map.put("物理", 95);
map.put("化学", 98);
System.out.println(map);
d = map.put("语文", 55);
System.out.println(d);
System.out.println(map);
/*
* V get(Object key)
* 根据给定的key获取对应的value，若
* 给定的key不存在，则返回值为null
*/
d = map.get("数学");
System.out.println("数学:"+d);
/*
* int size()
* 获取Map中的元素个数，每组键值对算
* 一个元素
*/
int size = map.size();
System.out.println("size:"+size);
/*
* V remove(K k)
* 将给定的key所对应的键值对删除。
* 返回值为该key对应的value。
*/
d = map.remove("语文");
System.out.println(map);
System.out.println(d);
}}
/**
* Map的遍历
* 遍历Map有三种方式
* 1:遍历所有的key
* 2:遍历每一组键值对
* 3:遍历所有的value(相对不常用)
*
* @author
*/
public class MapDemo2 {
public static void main(String[] args) {
Map<String,Integer> map
= new LinkedHashMap<String,Integer>();
map.put("语文", 98);
map.put("数学", 97);
map.put("英语", 96);
map.put("物理", 95);
map.put("化学", 98);
System.out.println(map);
/*
* 遍历所有的key
* Set<K> keySet()
* 将当前Map中所有的key以一个Set集合
* 形式返回。遍历这个集合就等同于遍历
* 了所有的key
*/
Set<String> keySet = map.keySet();
for(String key : keySet) {
System.out.println("key:"+key);
}
/*
* 遍历每一组键值对
* Set<Entry> entrySet()
*
*
* Entry的每一个实例用于表示当前Map中的
* 一组键值对。其中有两个常用的方法:
* getKey(),getValue()分别用于获取对应的
* key与value
*/
Set<Entry<String,Integer>> entrySet
= map.entrySet();
for(Entry<String,Integer> e: entrySet) {
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key+":"+value);
}
/*
* 遍历所有的value
*/
Collection<Integer> values = map.values();
for(Integer value : values) {
System.out.println("value:"+value);
} }}