复习中的java基础（实用）

1.String和StringBuffer的互换

String s="abc";
//不能把字符串直接赋值给StringBuffer
//String to StringBuffer;
//方式1
StringBuffer b=new StringBuffer(s);
//方式2
StringBuffer b=new StringBuffer();
b.append(s)
//StringBuffer to String
//方式1
String s=new String(b);
//方式2
s=b.toString();

String, StringBuilder, StringBuffer的区别

（1）运行速度由快到慢为：StringBuilder > StringBuffer > String

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

（2）线程安全：在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的。

如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

//int 转 String
//方式1
String a= String.valueof(num);
//方式2
Integer.toString(num);
//方式3
num+"";
//string 转int
//方式1
Integer.parseInt(str);
//方式2
Integer.valueof(str).intvalue();

2.单向链表arraylist

数据域data

指针域next

链表翻转

//方式1
//Stack
while(node!=null){
            stack.push(node.val);
            node=node.next;
        }
        while (!stack.isEmpty()){
            newlist.add(stack.pop());
        }
//方式2
//指针翻转
Node pre=head;
Node cur=head.next;
Node tmp;
while(cur!=null){
    tmp=cur.next;
    cur.next=pre;
    pre=cur;
    cur=tmp;
}
head.next=null;//原链表头部指针域设置为空
return pre;

3.重建二叉树（已知二叉树的前序，中序）

方式1：递归重建，重复确定左右子树。

public TreeNode reConstructBinaryTree(int [] pre, int [] mid)
{
if(pre.length==0 || mid.length==0){
return null;}
TreeNode node =new TreeNode(pre[0]);
for(int i=0;i<pre.length;i++){

if(pre[0]==mid[i]){
node.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(mid,0,i));
node.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(mid,i+1,in.length));
}

}
return node;
}

4.用两个栈实现队列

栈 first in last out;

队列 first in first out;

把stack1中的元素弹出到stack2中（确保stack2为空），返回stack2.pop（）

5.二分查找

（前提：数组有序或者旋转数组）时间复杂度o(logN)。坐标的移动

while(array[left]>=array[right]){
            if(right-left==1){
                mid=right;
                break;
            }
            mid=left+(right-left)/2;
            if(array[left]<=array[mid]){
                left=mid;
            }
            if(array[right]>=array[mid]){
                right=mid;
            }
        }
        return array[mid];
    }

6.斐波那契数列

//Fib
if(n==1 || n==2){
return 1;
}
return Fib(n-2)+Fib(n-1)

7.二进制问题

正数的原码，反码，补码都一样

（运算，采用补码运算）

负数的原码：符号位变为1。反码：除符号位按位取反。补码：反码+1

-1的补码：11111111

按位与（n & m）

左移一位 n=n<<1    相当于乘2

右移一位n=n>>1   相当于除2

8.快速幂算法

9.数组初始化

动态初始化：数组定义与为数组分配空间和赋值的操作分开

//动态初始化
int a[]//数组声明
a=new int[3];//分配空间
a[0]=1;//赋值
...

静态初始化：声明数组的同时为数组分配空间和赋值

//静态初始化
int a[]={1,2,3};

默认初始化：数组为引用类型，元素相当于累的成员变量，为数组分配空间时，按照类成员变量进行隐初始化

//默认初始化
int a[]=new int[3];
//其中a[0],a[1],a[2]的初始值默认为0

10.栈实现最小值的功能

利用一个辅助栈，来实现。一个存所有的值，另一个存最小值。

11.二叉树的创建，遍历

创建（1）传入一个数组。（2）指定左右子树 index*2+1，index*2+2

遍历 （1）前序，中序，后序。（2）深度优先（相当于前序遍历）：借助栈。广度优先：借助队列。

12.二叉搜索树

左子树小于根节点，右子树大于根节点。递归思想。

13.将二叉搜索树转换为双向的链表

中序遍历树