java进阶
java集合
Collection
List
ArrayList
jdk1.2,异步处理，性能高，线程不安全
Vector
jdk1.0,同步处理，性能低，线程安全
Set
HashSet
散列存放
hashCode是为了提高在散列结构存储中查找的效率，在线性表中没有作用。
若两个对象equals返回true，则hashCode有必要也返回相同的int数。
若两个对象equals返回false，则hashCode不一定返回不同的int数,但为不相等的对象生成不同hashCode值可以提高哈希表的性能。
若两个对象hashCode返回相同int数，则equals不一定返回true。
若两个对象hashCode返回不同int数，则equals一定返回false。
equals()对比是绝对可靠,hashCode不是绝对可靠
equals()效率低，hashcode效率高
先通过hashcode比较，相等时在比较equals,相对效率更高。
TreeSet
有序存放
TreeSet类型是J2SE中唯一可实现自动排序的类型
Map
//推荐，尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
HashMap
HashTable
Iterator
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
list.remove(2);
System.out.println(iterator.next());
}
//ConcurrentModificationException
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String str = iterator.next();
if(str.equals("A"))
iterator.remove();
else
System.out.println(str);
}
}
B
C
D
java文件
文件基本操作
File file = new File("hello.txt");
if(file.exists()){
//file.delete();
File file1 = new File("hello1.txt");
//重命名文件必须处于同一个分区内,不在同一个分区可以使用拷贝文件
file.renameTo(file1);
System.out.println(file.isDirectory());
}else{
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("文件创建失败");
}
}
java IO
使用字节流读取文件
try {
FileInputStream fis = new FileInputStream("hello.txt");
byte[] buffer = new byte[20];
fis.read(buffer);
String str = new String(buffer);
System.out.println(str);
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
使用字节流写入文件
try {
FileOutputStream fos = new FileOutputStream("test.txt");
String str = "test";
byte[] buffer = str.getBytes("UTF-8");
fos.write(buffer);
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
使用缓冲字节流读写文件
try {
FileInputStream fis = new FileInputStream("test.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("test1.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] buffer = new byte[1000];
bis.read(buffer);
bos.write(buffer);
bos.close();
fos.close();
bis.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
使用缓存字符流读取文件
File file = new File("hello.txt");
if(file.exists()){
try {
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
BufferedReader br = new BufferedReader(isr);
String line = null;
while ((line = br.readLine())!=null){
System.out.println(line);
}
br.close();
isr.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}else{
System.out.println("文件不存在");
}
对于文本文件读写：字符流效率高于字节流
FileReader与 FileWriter
try {
FileReader fr = new FileReader("test.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("test2.txt");
BufferedWriter bw = new BufferedWriter(fw);
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line + "
");
}
bw.flush();
bw.close();
fw.close();
br.close();
fr.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
RandomAccessFile
完成随机读取功能，可以读取指定位置的内容。
服务器的日志文件往往达到400多M，简单的文件读取实在太慢，太占用机器资源。如果需要统计一些即时数据。比如刚才10分钟的来访客户，即时扫描大数据文件中的一部分显得非常之重要，用RandomAccessFile。
Apache IO库
File file = new File("test.txt");
FileUtils.readFileToString(file,"UTF-8");
java 线程
线程的状态转换
run()方法是普通的方法调用，并不是启用线程,而start方法是首先启动一个新的线程，然后运行run()方法里面的代码。
Thread.currentThread().getName() //得到当前线程名字
A.join():堵塞当前线程B，直到A执行完毕并死掉，再执行B。
A.yield():让出位置，给B执行，B执行结束A再执行。与join相反。
Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态,不保证一定产生效果，仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态.
setPriority():设置线程优先级
优先级并不是很靠谱，因为Java线程是通过映射到系统的原生线程上来实现的，所以线程调度最终还是取决于操作系统。
Java线程调度就是抢占式调度。
stop()被弃用，本身不安全，会导致线程逻辑不完整。破坏了原子逻辑.用自定义的标志位停止线程。
线程的停止
class SafeStopThread extends Thread {
//此变量必须加上volatile
private volatile boolean stop = false;
@Override
public void run() {
//判断线程体是否运行
while (!stop) {
// Do Something
}
}
//线程终止
public void terminate() {
stop = true;
System.out.println("Stop");
}
}
继承Thread类创建线程
extend Thread，并复写run()方法
实现Runnable接口创建线程
实现run()方法
Callable FutureTask
实现Callable接口通过FutureTask包装器来创建Thread线程
Callable callable = new MyCallable();
FutureTask task = new FutureTask(callable);
Thread thread = new Thread(task);
thread.start();
try {
System.out.println(task.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
...
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
return 13;
}
}
使用ExecutorService、Callable、Future实现有返回结果的线程
ExecutorService executorService = new ThreadPoolExecutor(3,3,0,TimeUnit.DAYS,new LinkedBlockingQueue<Runnable>(2));
Callable callable1 = new MyCallable();
FutureTask task1 = new FutureTask(callable);
List<Future> futures = new ArrayList<>();
for (int i = 0; i < 3; i++) {
Callable c = new MyCallable();
Future f = executorService.submit(c);
futures.add(f);
}
for (Future f : futures) {
System.out.println(">>>" + f.get().toString());
}
同步和死锁
synchronized