Java_基础知识回顾

1、ByteArrayInputStream、 ByteArrayOutputStream

1. String str = "ZHANGSAN";
2. //System.out.println(str.toLowerCase());
3. ByteArrayInputStream inputStream = new ByteArrayInputStream(str.getBytes());
4. ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
5. int b;
6. while((b = inputStream.read()) != -1){
7. char lowerCase = Character.toLowerCase((char)b);
8. outputStream.write(lowerCase);
9. }
10. byte[] lowerCases = outputStream.toByteArray();
11. System.out.println(new String(lowerCases,0, lowerCases.length));

全部在内存中完成byte的转换

2、PrintStream：向目标打印

属于OutputStream的实现类，向目标(可能是文件、标准输出屏幕、输出流、网络等)打印各种样式，不过比一般的输出提供了更多的打印方式，可以打印各种数据类型和样式等

1. OutputStream outputStream = System.out;
2. outputStream.write("helloABC张三".getBytes());
3. outputStream.close();

列出当前操作系统的系统参数，输出到文件中

1. PrintStream printStream = new PrintStream("hello.txt");
2. System.getProperties().list(printStream); 
3. printStream.close();

3、InputStreamReader、OutputStreamWriter， 计算机存储都是字节流的形式，而读取到内存中需要识别一个个的字符(人只能识别字符)，有可能1个字节就代表一个字符(例如英文),也有可能多个字节才能转换成一个字符(例如中文)，如果中间存在丢失或无法转换，则看到的就是一堆?

InputStreamReader:将输入的内容字节变成字符

OutputStreamWriter:将输出的内容从字符变成字节

4、合并流：SequenceInputStream

1. File file1 = new File("hello.txt");
2. File file2 = new File("test.txt");
3. InputStream inputStream1 = new FileInputStream(file1);
4. InputStream inputStream2 = new FileInputStream(file2);
5. SequenceInputStream sequenceInputStream = new SequenceInputStream(inputStream1,
6. inputStream2);
7. BufferedInputStream bufferedInputStream = new BufferedInputStream(sequenceInputStream);
8. int c;
9. while((c = bufferedInputStream.read()) != -1){
10. System.out.print((char)c);
11. }
12. bufferedInputStream.close();
13. sequenceInputStream.close();
14. inputStream1.close();
15. inputStream2.close();

测试结果:helloworld

在实验中，从bufferedInputStream去取到两个文件大小相加的byte数组中,代码如下，转换出来有问题，有点奇怪，只读到了前一个流中的内容，后面一个流中的内容没读取进来。思考中...

1. File file1 = new File("hello.txt");
2. File file2 = new File("test.txt");
3. InputStream inputStream1 = new FileInputStream(file1);
4. InputStream inputStream2 = new FileInputStream(file2);
5. SequenceInputStream sequenceInputStream = new SequenceInputStream(inputStream1,
6. inputStream2);
7. BufferedInputStream bufferedInputStream = new BufferedInputStream(sequenceInputStream);
8. int length = (int) (file1.length() + file2.length());
9. byte[] b = new byte[length];
10. bufferedInputStream.read(b, 0, length);
11. System.out.println(new String(b,0,length));
12. bufferedInputStream.close();
13. sequenceInputStream.close();
14. inputStream1.close();
15. inputStream2.close();

测试结果如下：hello

5、Zip压缩与解压

压缩程序：

1. ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream("hello.zip"));
2. zipOutputStream.setLevel(9);
3. ZipEntry zipEntry = new ZipEntry("a.txt");
4. zipOutputStream.putNextEntry(zipEntry);
5. BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("test.txt"));
6. int content;
7. while((content = bufferedInputStream.read()) != -1){
8. zipOutputStream.write(content);
9. }
10. bufferedInputStream.close();
11. zipOutputStream.closeEntry();
12. zipOutputStream.flush();
13. zipOutputStream.close();

解压程序：

1. ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream("hello.zip"));
2. ZipEntry zipEntry = null;
3. while ((zipEntry = zipInputStream.getNextEntry()) != null) {
4. BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
5. new FileOutputStream(zipEntry.getName()));
6. int content = 0;
7. while((content = zipInputStream.read()) != -1){
8. bufferedOutputStream.write(content);
9. }
10. bufferedOutputStream.flush();
11. bufferedOutputStream.close();
12. }
13. zipInputStream.close();

6、zip压缩某目录下的所有文件及子文件

1. public void zipDirectory(File pathname, ZipOutputStream zipOutputStream) throws Exception {
2. if (!pathname.isDirectory()) {
3. return;
4. }
5. File[] files = pathname.listFiles();
6. for (File file : files) {
7. if (file.isDirectory()) {
8. zipDirectory(file, zipOutputStream);
9. } else {
10. ZipEntry zipEntry = new ZipEntry(pathname.getName() + File.separator
11. + file.getName());
12. zipOutputStream.putNextEntry(zipEntry);
13. BufferedInputStream bufferedInputStream = new BufferedInputStream(
14. new FileInputStream(file));
15. int i;
16. while ((i = bufferedInputStream.read()) != -1) {
17. zipOutputStream.write(i);
18. }
19. bufferedInputStream.close();
20. zipOutputStream.flush();
21. zipOutputStream.closeEntry();
22. }
23. }
24. }

问题：中文编码存在问题，建议选用import org.apache.tools.zip.ZipEntry;

import org.apache.tools.zip.ZipOutputStream，由于其存在方法out.setEncoding("gbk");//指定编码为gbk

6、ThreadLocal

1. final ThreadLocal<String> threadLocal = new ThreadLocal<String>();
2. threadLocal.set("main--");
3. Thread thread = new Thread() {
4. @Override
5. public void run() {
6. threadLocal.set("thread--");
7. Thread.yield();
8. System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());
9. }
10. };
11. thread.start();
12. Thread.yield();
13. System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());

7、数组和List之间的转换

数组->List: Arrays.asList(a)

List->数组:list.toArray()

8、正则表达式

(1)^：在[]内表示取反，在外面表示开头

(2)group

1. String regex = "[a-z]{3,5}";
2. Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
3. Matcher matcher = pattern.matcher("Abc_defgh_aa_ABCD1");
4. while (matcher.find()) {
5. System.out.print("位置[左闭右开区间):"+matcher.start() + "_" + matcher.end() + ", 匹配内容:");
6. System.out.println(matcher.group());
7. }

测试结果:

1. 位置[左闭右开区间):0_3, 匹配内容:Abc
2. 位置[左闭右开区间):4_9, 匹配内容:defgh
3. 位置[左闭右开区间):13_17, 匹配内容:ABCD

(3)邮件的正则表达式

[\\w[_.]]+@[\\w[_.]]+\\.[\\w]+

(4)"."点号在正则表达式中表示任何字符， 需要表示点号的时候必须转义\\.

(5)group的分组

分组是以正则表达式中的小括号'()'为标准的，当匹配成功后，group或group(0)表示匹配的整个字符串,group(1)代表正则中第一个小括号匹配到的内容,group(2)代表第二个小括号代表的内容，依次类推

(6)匹配require引入文件

"^[\\s]*#require[\\s]*\\(\"([\\w./]+)\"\\)[\\s]*$"含义为：以任意空白字符开头，在#require,再任意空白字符，再(",再任意字母、点号、斜线, 再"),最后任意个空白字符结尾

测试代码：

1. public static void main(String[] args) {
2. FileInputStream fileInputStream = null;
3. try {
4. fileInputStream = new FileInputStream(new File(
5. "C:/Documents and Settings/***/My Documents/tmp/hello.js"));
6. } catch (FileNotFoundException e) {
7. e.printStackTrace();
8. }
9. InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,
10. Charset.defaultCharset());
11. BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
12. String line = "";
13. try {
14. while ((line = bufferedReader.readLine()) != null) {
15. String requireFile = getRequireFile(line);
16. System.out.println(requireFile);
17. }
18. } catch (IOException e) {
19. e.printStackTrace();
20. } finally {
21. try {
22. bufferedReader.close();
23. inputStreamReader.close();
24. fileInputStream.close();
25. } catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29. }
30. private static String getRequireFile(String line) {
31. String requireFile = "";
32. Pattern pattern = Pattern
33. .compile("^[\\s]*#require[\\s]*\\(\"([\\w./]+)\"\\)[\\s]*$", Pattern.MULTILINE);
34. Matcher matcher = pattern.matcher(line);
35. while (matcher.find()) {
36. requireFile = matcher.group(1);
37. }
38. return requireFile;
39. }

测试文件内容:

1. var param;
2. #require("hello/world_util/alibaba123_utils.js")
3. #require("/abc/world_util/alibaba12666_utils.js")

测试结果

1. hello/world_util/alibaba123_utils.js
2. /abc/world_util/alibaba12666_utils.js

9、FileReader有待完备的地方，只能使用系统默认的字符集，而没有提供传递字符集的构造函数

FileReader继承了InputStreamReader，但并没有实现父类中带字符集参数的构造函数，所以
FileReader只能按系统默认的字符集来解码

10、阻塞队列：BlockingQueue

生产者中的 put() 操作会在没有空间可用时阻塞，而消费者的 take() 操作会在队列中没有任何东西时阻塞。

11、信号量：Semaphore, 允许规定数量的线程进入操作，释放之后其他进入执行

1. Runnable limitedCall = new Runnable() {
2. final Random    rand      = new Random();
3. final Semaphore available = new Semaphore(3);
4. int             count     = 0;
5. public void run() {
6. int time = rand.nextInt(15);
7. int num = count++;
8. try {
9. available.acquire();
10. System.out.println("Executing " + "long-running action for " + time
11. + " seconds... #" + num);
12. Thread.sleep(time * 1000);
13. System.out.println("Done with #" + num + "!");
14. available.release();
15. } catch (InterruptedException intEx) {
16. intEx.printStackTrace();
17. }
18. }
19. };
20. for (int i = 0; i < 10; i++)
21. new Thread(limitedCall).start();

12、死锁

1. public class Demo06 {
2. public static void main(String[] args) {
3. DeadLock deadLock1 = new DeadLock();
4. DeadLock deadLock2 = new DeadLock();
5. deadLock1.setFlag(true);
6. deadLock2.setFlag(false);
7. new Thread(deadLock1).start();
8. new Thread(deadLock2).start();
9. }
10. }
11. class DeadLock implements Runnable {
12. private boolean flag = false;
13. public boolean isFlag() {
14. return flag;
15. }
16. public void setFlag(boolean flag) {
17. this.flag = flag;
18. }
19. private static Object object1 = new Object();
20. private static Object object2 = new Object();
21. public void run() {
22. if (flag) {
23. synchronized (object1) {
24. System.out.println(Thread.currentThread().getName() + " get object1.");
25. try {
26. Thread.sleep(1000);
27. } catch (InterruptedException e) {
28. e.printStackTrace();
29. }
30. synchronized (object2) {
31. System.out.println(Thread.currentThread().getName() + " get object2.");
32. }
33. }
34. } else {
35. synchronized (object2) {
36. System.out.println(Thread.currentThread().getName() + " get object2.");
37. try {
38. Thread.sleep(1000);
39. } catch (InterruptedException e) {
40. e.printStackTrace();
41. }
42. synchronized (object1) {
43. System.out.println(Thread.currentThread().getName() + " get object1.");
44. }
45. }
46. }
47. }
48. }

13、反射：通过classloader加载类，标准做法如下：

1. ClassLoader cl = Thread.currentThread().getContextClassLoader();
2. if (cl == null) cl = MyClass.class.getClassLoader(); // fallback
3. Class clazz = cl.loadClass(name);

14、文件大小限制

错误做法：

1. public int getFileSize(File f) {
2. long l = f.length();
3. return (int) l;
4. }

正确做法如下：

不支持传递超过2GB的文件. 最好的做法是对长度进行检查, 溢出时抛出异常

1. public int getFileSize(File f) {
2. long l = f.length();
3. if (l > Integer.MAX_VALUE) throw new IllegalStateException("int overflow");
4. return (int) l;
5. }

15、线程sleep中断

1. try {
2. Thread.sleep(1000);
3. } catch (InterruptedException e) {
4. Thread.currentThread().interrupt();
5. }
6. or
7. while (true) {
8. if (Thread.currentThread().isInterrupted()) break;
9. }

16、开发中常用术语解释

java的几种对象(PO,VO,DAO,BO,POJO)解释  
   一、PO:persistant object 持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。

二、VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可以和表对应,也可以不,这根据业务的需要.个人觉得同DTO(数据传输对象),在web上传递。

三、DAO:data access object 数据访问对象，此对象用于访问数据库。通常和PO结合使用，DAO中包含了各种数据库的操作方法。通过它的方法,结合PO对数据库进行相关的操作。

四、BO:business object 业务对象,封装业务逻辑的java对象,通过调用DAO方法,结合PO,VO进行业务操作。

五、POJO:plain ordinary java object 简单无规则java对象,我个人觉得它和其他不是一个层面上的东西,VO和PO应该都属于它。

17、多线售票系统：

1. class TicketSeller implements Runnable {
2. private int ticketCount = 10;
3. @Override
4. public void run() {
5. while (ticketCount > 0) {
6. synchronized (this) {
7. if (ticketCount > 0) {
8. try {
9. Thread.sleep(100);
10. } catch (InterruptedException e) {
11. e.printStackTrace();
12. }
13. System.out.println(Thread.currentThread().getName()
14. + " sell ticket: " + ticketCount--);
15. }
16. }
17. }
18. }
19. }
20. public class Demo01 {
21. public static void main(String[] args) {
22. TicketSeller ticketSeller = new TicketSeller();
23. new Thread(ticketSeller, "Thread A").start();
24. new Thread(ticketSeller, "Thread B").start();
25. new Thread(ticketSeller, "Thread C").start();
26. new Thread(ticketSeller, "Thread D").start();
27. }
28. }

 测试结果：

1. Thread A sell ticket: 10
2. Thread A sell ticket: 9
3. Thread D sell ticket: 8
4. Thread D sell ticket: 7
5. Thread D sell ticket: 6
6. Thread C sell ticket: 5
7. Thread C sell ticket: 4
8. Thread C sell ticket: 3
9. Thread B sell ticket: 2
10. Thread B sell ticket: 1

18、中断处理

1. class TicketSeller implements Runnable {
2. @Override
3. public void run() {
4. try {
5. System.out.println("线程启动");
6. Thread.sleep(10000);
7. } catch (InterruptedException e) {
8. System.out.println("线程被中断");
9. // e.printStackTrace();
10. }
11. }
12. }
13. public class Demo01 {
14. public static void main(String[] args) throws InterruptedException {
15. TicketSeller ticketSeller = new TicketSeller();
16. Thread thread = new Thread(ticketSeller, "Thread A");
17. thread.start();
18. System.out.println("====主线程执行===");
19. Thread.sleep(1000);
20. // thread.interrupt();
21. System.out.println("线程被中断否：" + thread.isInterrupted());
22. thread.interrupt();
23. System.out.println("线程被中断否：" + thread.isInterrupted());
24. System.out.println("线程被中断否2：" + thread.isInterrupted());
25. System.out.println("主线程是否被中断：" + Thread.interrupted());
26. System.out.println("====主线程结束===");
27. }
28. }

 测试结果：

1. ====主线程执行===
2. 线程启动
3. 线程被中断否：false
4. 线程被中断否：true
5. 线程被中断否2：true
6. 主线程是否被中断：false
7. 线程被中断
8. ====主线程结束===

结论：

 interrupt中断该线程， isInterrupted检查该线程是否被中断， interrupted检查当前线程是否被中断。