Java中有很多内容在开发项目的过程中并不常用，但是却是很重要的部分，为了避免忘记，今天重新温习了一遍Java中的重点和难点，借此机会记录一下方便以后查找。
本文主要分为以下几个部分：
1.进制的相互转换
2.Java中位运算符的解释和运用
3.Java数组中常用的排序算法分析
4.Java中折半查找方法的分析和运用
5.Java中对象的初始化过程
6.Java抽象类在模板方法模式中的运用
7.Java多线程的难点和设计多线程程序时需要注意的问题
8.Java中集合框架运用时需要注意的问题
9.Java中IO难点和重点的分析
10.Java网络编程的分析和运用
11.Java中常用正则表达式的运用和技巧
第一部分：进制的相互转换
1.十进制和二进制的相互转换
十进制转二进制：
int num = 102;
StringBuffer sb = new StringBuffer();
while(num >= 1) {
sb.append(num%2);
num = (int) (num / 2);
}
System.out.println(sb.reverse());
二进制转十进制：
String binaryStr = "1100110";
int num = 0;
for (int i = 0; i < binaryStr.length(); i++){
num += Integer.parseInt(String.valueOf(binaryStr.charAt(binaryStr.length() - 1 - i))) << i;
}
System.out.println(num);
第二部分：Java中位运算符的解释和运用
Java中一共有7个位运算符分别是<<、>>、&、|、^、~、>>>
1.“<<”--左移运算符，参与左移运算的数字乘以2的左移位数次方，例如3<<2=3*22
2.“>>”--右移运算符，参与右移运算的数字除以2的右移位数次方，例如3>>2=3/22
3.“&” --与运算符，参与与运算的两个数字的二进制等位都为1时结果值的该位为1，其余情况为0，例如3&2=0011&0010=0010,与运算符和“>>>”运算符结合可以实现十进制转十六进制的功能，num&15 -> num>>>4，这样一组运算就能得到一个十六进制位，再将超过10的通过(num-10)+'A'转换为十六进制位
4.“|” --或运算符，参与或运算的两个数字的二进制等位至少有一个为1时结果值的该位为1，其余情况为0，例如3|2=0011|0010=0011
5.“^” --异或运算符，参与异或运算的两个数字的二进制等位如果不相同则为1，相同则为0，一个数字异或同一个数字两次则等于原数字。其中一个应用是在不使用第三个变量的情况下交换两个整形变量的值。
int n = 4,m = 6;
//此时n = n ^ m的值
n = n ^ m;
//此时m = n ^ m,因为上句代码执行后n = n ^ m，所以这里m = n ^ m = n ^ m ^ m = n(这里的m = n中的n = 4)
m = n ^ m;
//此时m = n,n = n ^ m , 所以n = n ^ m = n ^ m ^ n=m（这里的n = m中的m = 6）
n = n ^ m;
6.“~” --取反运算符，参与取反运算的数字的所有二进制位都取相反的值，0变成1,1变成0，因为一个正数的负数或者一个负数的正数等于它取反然后加1，所以一个数取反则等于该数乘以-1然后减去1
7.“>>>” --无符号右移，高位补零，功能和右移类似
第三部分：Java数组中常用的排序算法
1.选择排序
int[] attr = {3,6,5,85,2,44,1,46,67,0,45,4,134,123,112};
for(int x = 0;x < attr.length() - 1, x++) {
for(int y = x + 1; y < attr.length(); y++) {
if(attr[x]<attr[y]) {
attr[x] = attr[x] ^ attr[y];
attr[y] = attr[x] ^ attr[y];
attr[x] = attr[x] ^ attr[y];
}
}
}
for(int i in attr) {
System.out.print(i + " ");
}
2.冒泡排序
int[] attr = {3,6,5,85,2,44,1,46,67,0,45,4,134,123,112};
for(int x = attr.length() - 1;x >= 0; x--) {
for(int y = 0; y < x;y++) {
if(attr[y] < attr[y + 1]) {
attr[y] = attr[y] ^ attr[y + 1];
attr[x] = attr[y] ^ attr[y + 1];
attr[y] = attr[y] ^ attr[y + 1];
}
}
}
for(int i in attr) {
System.out.print(i + " ");
}
第四部分：Java中折半查找方法的分析和运用
折半查找的原理是先将数组排序（从小到大，如果是从大到小则需要一些改变），然后找到数组中的中间数，然后把中间数和需要查找的数进行比较，如果需要查找的数小于中间数则将最大索引赋值为中间结果索引+1，反之则把最小索引赋值为中间结果-1。代码如下：
int[] attr = {3,6,5,85,2,44,1,46,67,0,45,4,134,123,112};
int min = 0;
int max = attr.length();
int mid = (int) (min + max) / 2;
Arrays.sort(attr);
int key = 67;
int keyIndex = -1;
while(min <= max) {
if(key < attr[mid]) {
max = mid + 1;
} else if(key > attr[mid]) {
min = mid - 1;
} else {
keyIndex = mid;
break;
}
mid = (int) (min + max) / 2;
}
if(keyIndex != -1) {
System.out.println(attr[mid]);
}
第五部分：Java中对象的初始化过程
初始化静态代码块
初始化属性默认值
初始化属性显示设置值
初始化构造代码块
初始化构造函数
第六部分：Java抽象类在模板方法模式中的运用
这里举一个简单的示例代码来说明，代码如下：
//首先声明一个抽象类，这个抽象类的作用是计算一段代码的执行时间
public abstract class GetTime {
public final void getDoWorkTime() {
int start = System.currentTimeMillis();
doWork();
int end = System.currentTimeMillis();
System.out.println("工作时间：" + (start - end));
}
public abstract void doWork();
}
//声明一个GetTime类的子类，并实现doWork方法
public class SubGetTime extends GetTime {
@Override
public void doWork() {
System.out.println("做一些工作");
}
}
public class Test {
public static void main(String[] args) {
SubGetTime getTime = new SubGetTime();
getTime.getDoWorkTime();
}
}
//这里的doWork方法声明为抽象方法，然后交给子类去实现需要做的工作，这种方式就是模板方法模式，这是设计模式中行为模式中的一种
第七部分：Java多线程的难点和设计多线程程序时需要注意的问题
Java多线程中的难点和重点主要是线程安全的问题，这里就主要说一下线程安全的问题，因为在JDK1.5后Java引入了Lock和Condition来代替synchronized、wait和notify，所以这里分两种情况来讨论。
首先在Java中创建线程的方式有两种，第一种是继承Thread类然后复写run方法，第二种方式是实现Runable接口并实现run方法。
继承Thread：
public class SaveMoney extends Thread {
@Override
public void run() {
System.out.println("存钱");
}
}
public class GetMoney extends Thread {
@Override
public void run() {
System.out.println("取钱");
}
}
public class BankTest {
public static void main(String[] args) {
SaveMoney saveMoneyThread = new SaveMoney();
GetMoney getMoneyThread = new GetMoney();
saveMoneyThread.start();//启动线程，这里如果调用run是执行run方法不是启动线程，需要注意
getMoneyThread.start();
}
}
实现Runable接口：
public class SaveMoney implements Runable {
public void run() {
System.out.println("存钱");
}
}
public class GetMoney implements Runable {
public void run() {
System.out.println("取钱");
}
}
public class BankTest {
public static void main(String[] args) {
new Thread(new SaveMoney()).start();//启动线程，这里如果调用run是执行run方法不是启动线程，需要注意
new Thread(new GetMoney()).start();
}
}
下面就在JDK1.5之前和JDK1.5之后两种情况下结合银行取钱和存钱的例子来说明线程同步的问题
JDK1.5之前：
//首先创建一个用户帐户类
public class BankAccont {
private String accontName = "";
private Double totalMoney = 0d;
public BankAccont(String accontName, Double initMoney) {
this.accontName = accontName;
this.totalMoney = initMoney;
}
public void saveMoney(Double money) {
this.totalMoney += money;
System.out.println("存了" + money + "块钱");
}
public void getMoney(Double money) {
this.totalMoney -= money;
System.out.println("取了" + money + "块钱");
}
public String toString() {
System.out.println(this.accontName + "总共还有" + this.totalMoney + "元人民币");
}
}
//分别创建存钱和取钱的线程，使用实现Runable接口的方式这种方式可以轻松的让不同的线程执行相同的任务，除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类
public class SavaMoney implements Runable {
private BankAccont accont = null;
public SaveMoney(BankAccont accont) {
this.accont = accont;
}
public void run() {
//这里使用同一个锁进行同步
synchronized(BankAccont.class) {
while(true) {
this.accont.saveMoney(100);
}
}
}
}
public class GetMoney implements Runable {
private BankAccont accont = null;
public GetMoney(BankAccont accont) {
this.accont = accont;
}
public void run() {
//这里使用同一个锁进行同步
synchronized(BankAccont.class) {
while(true) {
this.accont.getMoney(100);
}
}
}
}
public class BankTest {
public static void main(String[] args) {
BankAccont accont = new BankAccont("张三", 1000);
new Thread(new SaveMoney(accont)).start();
new Thread(new GetMoney(accont)).start();
accont.toString();
}
}
JDK1.5之后：
//首先创建一个用户帐户类
public class BankAccont {
private String accontName = "";
private Double totalMoney = 0d;
private final Lock lock = new RentrantLock();
private final Condition condition_save = lock.newCondition();
private final Condition condition_get = lock.newCondition();
public BankAccont(String accontName, Double initMoney) {
this.accontName = accontName;
this.totalMoney = initMoney;
}
public void saveMoney(Double money) {
lock.lock();
condition_get.await();//这里引用不合适，只是一个示例
this.totalMoney += money;
System.out.println("存了" + money + "块钱");
condition_get.signal();//这里引用不合适，只是一个示例
lock.unlock();
}
public void getMoney(Double money) {
lock.lock();
condition_save.await();//这里引用不合适，只是一个示例
this.totalMoney -= money;
System.out.println("取了" + money + "块钱");
condition_save.signal();//这里引用不合适，只是一个示例
lock.unlock();
}
public String toString() {
System.out.println(this.accontName + "总共还有" + this.totalMoney + "元人民币");
}
}
//分别创建存钱和取钱的线程，使用实现Runable接口的方式这种方式可以轻松的让不同的线程执行相同的任务，除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类
public class SavaMoney implements Runable {
private BankAccont accont = null;
public SaveMoney(BankAccont accont) {
this.accont = accont;
}
public void run() {
while(true) {
this.accont.saveMoney(100);
}
}
}
public class GetMoney implements Runable {
private BankAccont accont = null;
public GetMoney(BankAccont accont) {
this.accont = accont;
}
public void run() {
while(true) {
this.accont.getMoney(100);
}
}
}
public class BankTest {
public static void main(String[] args) {
BankAccont accont = new BankAccont("张三", 1000);
new Thread(new SaveMoney(accont)).start();
new Thread(new GetMoney(accont)).start();
accont.toString();
}
}
以上只是一个简单的示例，需要根据需要进行修改。在设计多线程程序的时候需要多考虑线程同步的问题（线程安全），在多线程中还有一个问题就是Java中有哪些线程安全的集合？
Java中线程安全的集合分别是Vector(向量，已经不常用了)、HashTable、Enumeration(枚举),除了这几个其余都为线程不安全集合。StringBuffer和StringBuider的差别也是StringBuffer为线程安全，StringBuider为线程不安全。
Java多线程相关的问题，暂时只想到这些，再想起的时候再补充。
欢迎工作一到五年的Java工程师朋友们加入Java架构开发： 957734884，群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用"没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！
