一、字符串常见的操作
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");