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");