Java基础知识复习（二）

1.NPE（空指针异常）:
指通过一个引用操作其指向的对象的属性或者方法时，该引用为null。
常见的几种空指针异常：
引用.属性
引用.方法
数组引用 Array[0] Array{}==null
synchronized(引用）{}
2.MyLinkedList元素类型（String):
add(e) 尾插
add(index,e) 在index位置添加e
remove（index） 删除index位置元素
remove（e) 删除第一个遇到的e
get (index) 返回index位置元素
set (index,e) 修改index位置元素
contain (e) 是否包含e
indexof(e) 返回第一个e的下标，找不到就返回-1
LastIndexof(e) 从后面找，返回第一个e的下标
3.链表方法要不要使用static
首先要判断这个方法是不是和该类对象有关系
以add方法为例，如果有两个链表对象，调用一个对象的add,期望不对另一个链表对象产生影响，说明add 方法和对象有关系，不应该使用static，所以说，凡是和对象有关系的方法和属性，都不应该使用static。
4.链表插入练习
先创建节点类，定义共用引用；

public class Node {
    String  val;
    Node  prev;
    Node  next;
    Node(String val){
        this.val=val;
    }
}

创建链表，实现尾插和指定节点插入；

public class MyLinkeList {
    private  Node head;
    private  Node last;
    private   int size;
    //尾插练习
   public boolean add(String e){
       //把元素添加到节点对象中
       Node node=new Node(e);
       //区分链表是否为空的情况
       if(head==null){
           //链表为空
           head=last=node;
       }else{
           //链表不为空
           node.prev=last;
           last.next=node;
           last=node;
       }
          return true;
   }
   //指定位置插入练习
public void add(int index, String e){
       if(index<0||index>size()) {
    throw new IndexOutOfBoundsException("下标越界"+index);
       }
           //把元素添加到节点对象中
       Node node =new Node(e);
       if(head==null){
           //index一定是0，否则在上面抛异常
           head=last=node;
       }else if(index==0){
           //头插
       node.next=head;
       head.prev=node;
       head=node;
       }else if(index==size()){
      //尾插
           node.prev=last;
           last.next=node;
           last=node;
       }else{
        Node prev=head;
        for(int i=0;i<index-1;i++){
            prev=prev.next;
        }
        //指定index节点插入
        Node next=prev.next;
        node.prev=prev;
        node.next=next;
        prev.next=node;
        next.prev=node;
       }
       size++;
}
    public int size(){
        return size;
    }
}

指定位置插入示意图：

5.链表删除练习

  //指定位置插入练习
public void add(int index, String e){
       if(index<0||index>size()) {
    throw new IndexOutOfBoundsException("下标越界"+index);
       }
           //把元素添加到节点对象中
       Node node =new Node(e);
       if(head==null){
           //index一定是0，否则在上面抛异常
           head=last=node;
       }else if(index==0){
           //头插
       node.next=head;
       head.prev=node;
       head=node;
       }else if(index==size()){
      //尾插
           node.prev=last;
           last.next=node;
           last=node;
       }else{
           Node prev = getpreviousByindex(index);
           Node next=prev.next;
        node.prev=prev;
        node.next=next;
        prev.next=node;
        next.prev=node;
       }
       size++;
}

    private Node getpreviousByindex(int index) {
        Node prev=head;
        for(int i=0;i<index-1;i++){
            prev=prev.next;
        }
        return prev;
    }
//指定位置删除节点练习
    public String remove(int index){
        if(index<0||index>size()) {
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
        String v=null;//记录返回值
        //不越界有两种情况，链表只有一个元素和链表有多个元素
        //只有一个元素情况
        if(size()==1){
            head=last=null;
            v=head.val;
        }else if(index==0){
            //头删情况
            head=head.next;
            head.prev=null;
            v=head.val;
        }else if(index==size()-1){
            //尾删情况
            last=last.prev;
            last.next=null;
            v=last.val;
        }else{
       Node prev=getpreviousByindex(index);
       Node node=prev.next;
       Node next=node.next;
            prev.next=next;
            next.prev=prev;
            v=node.val;
        }
        size--;
       return v;
    }
    //删除第一个遇到的e练习
    public boolean remove(String e){
       Node current=head;
       while(current!=null){
           if(current.val.equals(e)){
               Node prev=current.prev;
               Node next=current.next;
               if(prev!=null){
                   prev.next=next;
               }else{
                   head =head.next;
               }
               if(next!=null){
                   next.prev=prev;
               }else{
                   last=last.prev;
               }
               size--;
               return true;
           }
           current=current.next;
       }
       return false;
    }
    public int size(){
        return size;
    }

6.递归问题
当面临一个问题规模为n的问题A，我们发现可以将这个规模为n的问题分解成一个或多个子问题，这些子问题也是A类问题，问题规模是m，m<n;
例子：
求X的阶乘：

 public int fac(int x){
           if(x==1){
               return 1;
           }else{
             return x*fac(x-1);  
           }
       }