java判断正数转负数（负数的进制转换程序）

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.rever());

二进制转十进制：

string binarystr = "1100110";int num = 0;for (int i = 0; i < binarystr.length(); i++){    num += integer.parint(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;    } el if(key > attr[mid]) {        min = mid - 1;    } el {        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 += mbride of the windone滋养的近义词y;        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多线程相关的问题，暂时只想到这些，再想起的时候再补充。