Java初学者笔记三：关于字符串和自实现数组常见操作以及异常处理

一、字符串常见的操作

1、结合我在python中对于字符串常见处理总结出下面三个应该能算是字符串造作的TOP 3

//字符串查找子串,存在返回index，不存在返回-1 等于python的find：
String string = "abcdefg";
string.indexOf("cd");

//字符串的替换:
string = string.replace("old","new");

//字符串的拆分：
stringlist = string.split(",");
for(String each:stringlist){
  System.out.println(each);  
}

2、这里涉及一个常见的增强循环，有点类似于python中对可迭代对象的迭代

for(数据类型 item:迭代对象){
  do_something();  
}

二、自实现数据

1、关于基本数组的概念，这里就不在赘述了，也没啥说的，这里主要想自己实现一个动态数组，结合python的list感觉就是一个实现动态数组的绝佳例子，而且也方便做队列和栈等。

可以实现append、extend、remove、iterator、切片、len等基本功能。如果想实现FIFO或者FILO类的数据结构（队列或栈）则继承之后实现push和pop等操作就好了。

/*
 * 目的：为了实现类似python的list的功能而定义这个数据结构
 * 作者：陈然
 * 版本：v0.1
 * 声明：高度python爱好者
*/

/*引入包文件*/
import java.io.*;
import java.lang.*;
import java.util.Iterator;//为了实现增强循环引入迭代器  

/*定义基础类myList的数据结构*/
class List implements Iterable<Object>{
    /*我的仿Python的Java的ist数据结构*/
    /*定义成员属性*/
    protected Object[] array;//可以传入任意对象的list的存储空间
    protected int size;//数组的元素数量
    
    /*定义构造方法*/
    List(){}
    List(int size,Object[] object){
        this.size = size;
        this.array = new Object[object.length];
        System.arraycopy(object, 0, this.array, 0, size);
    }
    /*定义成员方法*/
    public boolean clear() {
        //清空列表
        try {
            this.size = 0;
            this.array = new Object[0];
            return true;
        }
        catch(Exception reason){
            return false;
        }
    }
    
    public int getSize() {
        //返回列表长度
        return this.size;
    }
    
    public List getPices(int start,int end) throws Exception {
        int length = 0;
        boolean flag = false;
        if(start >= 0 && end >=start) {
            length = end-start;
        }
        else if(start < 0 && end <= start) {
            length = start - end;
            flag = true;
        }
        else {
            throw new Exception("");
        }
        Object[] helper = new Object[length];
        int fence = 0;
        if(!flag) {
            for(int i=start;i<end;i++) {
                helper[fence] = this.array[i];
                fence++;
            }
        }else {
            for(int i=0;i<length;i++) {
                helper[fence] = this.array[this.array.length-1-i];
                fence++;
            }
        }
        return new List(helper.length,helper);
    }
    
    public boolean append(Object object) throws Exception{
        try {
            if(this.size == 0) {
                try {
                    this.array = new Object[1];
                    this.array[0] = object;
                    this.size ++;
                    return true;
                }
                catch(Exception reason) {
                    return false;
                }
            }
            else {
                Object[] helper = new Object[this.size+1];
                System.arraycopy(this.array, 0, helper, 0, this.array.length);
                helper[this.size] = object;
                this.array = new Object[helper.length];
                System.arraycopy(helper, 0, this.array, 0, helper.length);
                this.size++;
                return true;
            }
        }
        catch(Exception reason) {
            return false;
        }
    }
    
    public boolean extend(Object[] exarray) throws Exception{
        try {
            if(this.size == 0) {
                this.array = new Object[exarray.length];
                System.arraycopy(exarray, 0, this.array, 0, exarray.length);
                this.size = this.array.length;    
                return true;
            }
            else {
                Object[] helper = new Object[this.size+exarray.length];
                System.arraycopy(this.array, 0, helper, 0, this.size);
                System.arraycopy(exarray, 0, helper, this.size, exarray.length);
                this.array = new Object[helper.length];
                System.arraycopy(helper, 0, this.array, 0, helper.length);
                this.size += exarray.length;
                return true;
            }
        }catch(Exception reason) {
            return false;
        }
    }
    
    public boolean removeByIndex(int index) throws Exception {
        if(index >= this.size) {
            return false;
        }
        else {
            try {
                Object[] helper = new Object[this.size-1];
                System.arraycopy(this.array, 0, helper, 0, index);
                System.arraycopy(this.array, index+1, helper, index, helper.length-index);
                this.array = new Object[helper.length];
                System.arraycopy(helper, 0, this.array, 0, helper.length);
                this.size --;
                return true;
            }catch(Exception reason) {
                return false;
            }
        }
    }
    
    public boolean removeByObject(Object object) throws Exception {
        for(int i=0;i<this.size;i++) {
            if(this.array[i] == object){
                return this.removeByIndex(i);
            }
        }
        return false;
    }
    
    @Override
    public Iterator<Object> iterator() {
        //重载迭代器
        return new Iterator<Object>() {
            int cursor = 0;//索引下标
            
            @Override
            public boolean hasNext() {
                return cursor < size;
            }

            @Override
            public Object next() {
                return (Object)array[cursor++];
            }
            @Override
            public void remove() {}
        };
    }
    
}

知识点1：

/*关于数组的拷贝*/
System.arraycopy(sarray,startindex,darray,startindex,copysize);

知识点2：

/*异常处理*/
//对于函数定义时候抛出异常
public void function_name throws Exception(){}

//代码块
try{
 //...       
}catch(Exception reason){
 //...   
}

//抛出异常
throw new Exception("xxxxxx");