集合框架：
自定义数据结构(增删改查等)
package 数组;
/**
* 创建动态数组
* @author 百合
*
*/
public class ArrayDemo{
//定义一个数组来存放数据
String[] src = new String[0];
/**
* 增加元素加入容器
* @param s要加入容器的个数
*/
public void add(String s){
//创建一个新的数组，长度为src+1；
String[] dest = new String[src.length+1];
//将新加入的数组放在数组的最后一位
dest[dest.length-1] = s;
//将src数组的值copy到dest数组里面
for(int i = 0;i<src.length;i++){
dest[i] = src[i];
}
//将src指向新数组
src = dest;
}
/**
* 获取元素的地址
* @param index
* @return
*/
public String get(int index){
return src[index];
}
/**
* 修改指定位置的元素
* @param index修改的元素位置
* @param s修改后的新元素
*/
public void update(int index,String s){
if(index >=0 && index<size()){
src[index]= s;
}else{
System.out.println("指定的下标超出范围");
}
}
/**
* 将指定的元素插入到指定的位置
*/
public void insert(int index,String s){
if(index>=0 && index <size()){
String[] dest = new String[src.length+1];
//将插入的数组放到指定的位置
dest[index] = s;
for(int i = 0;i < index;i++){
dest[i] = src[i];
}
for(int i = index;i<src.length;i++){
dest[i+1] = src[i];
}
//将src指新数组
src = dest;
}else{
System.out.println("指定的下标超出范围");
}
}
/**
* 删除指定位置的元素
* @param inde下标的元素
*/
public void dalete(int index){
String[] dest = new String[src.length-1];
for(int i = 0;i<index;i++){
dest[i] = src[i];
}
for(int i = index +1;i<src.length;i++ ){
dest[i-1] = src[i];
}
src = dest;
}
/**
*
* @return 返回得到容器的元素的个数
*
*/
public int size(){
return src.length;
}
}
//测试ArrayDemo数组
//泛型的类类型，可以调用方法
package 数组;
public class ArrayTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//获得系统时间
long t1 = System.currentTimeMillis();
System.out.println(t1);
ArrayDemo am = new ArrayDemo();
am.add("元素1");
am.add("元素2");
am.add("元素3");
am.add("元素4");
am.add("元素5");
//am.dalete(4);
am.insert(0,"元素六");
long t2 = System.currentTimeMillis();
System.out.println(t2);
//遍历
for(int i = 0;i<am.size();i++){
String num = am.get(i);
System.out.println(num);
System.out.println(Math.abs(t2-t1));
}
System.out.println(Math.abs(t2-t1));
}
}
//修改后的数组，使用泛型可以存储任意的类型
/**
* 动态数组，用来装任意类型的动态数组
*
* @author 百合
*
*/
public class ArrayQueue<E> {
private int len = 0;// 长度
private int initContiner;// 初始容量
private int rate;// 增长比率
// 定义一个用来存放数据的数组
// 初始长度为0，表示没有装任何数据
Object[] src;
public ArrayQueue() {
this.initContiner = 10;
this.rate = 10;
src = new Object[initContiner];
}
// 创建容器对象的时候指定容量和增长比率
public ArrayQueue(int initContiner, int rate) {
this.initContiner = initContiner;
this.rate = rate;
src = new Object[initContiner];
}
/**
* 将指定的元素加入容器
*
* @param s
* 要加入到容器中的元素
*/
public void add(E s) {
// 如果长度小于容量,就将元素放到数组第一个为null的位置
if (len >= src.length) {
// 创建新数组
// 定义一个新数组，用来装数据,长度比src+1
Object[] dest = new Object[src.length + rate];
// 将源数组中的数据按照下标顺序拷贝到新数组
System.arraycopy(src, 0, dest, 0, len);
src = dest;
}
src[len] = s;
len++;
}
/**
* 获取指定下标位置的元素
*
* @param index
* 要获取的元素的下标
* @return 返回获取到的元素
*/
public E get(int index) {
return (E) src[index];
}
/**
* 修改指定位置元素的值
*
* @param index要修改的元素位置
* @param s
* 修改后的新元素
*/
public void update(int index, E s) {
if (index >= 0 && index < size()) {
src[index] = s;
} else {
System.out.println("指定的下标超出范围！！！");
}
}
/**
* 将指定元素插入到指定位置
*
* @param index
* 要插入元素的位置
* @param s
* 要插入的新元素
*/
public void insert(int index, E s) {
if (index >= 0 && index < size()) {
// 定义新数组，长度比原数组+1
Object[] dest = new Object[src.length + 1];
// 将新元素放到新数组的指定位置
dest[index] = s;
// 将源数组中下标<index,拷贝到新数组相同的下标位置
for (int i = 0; i < index; i++) {
dest[i] = src[i];
}
// 将源数组中其他下标的元素拷贝到新数组下标+1的位置
for (int i = index; i < src.length; i++) {
dest[i + 1] = src[i];
}
// 将src指向新数组
src = dest;
} else {
System.out.println("指定的下标超出范围！！！");
}
}
/**
* 删除指定位置的元素
*
* @param index
* 要删除的元素的下标
*/
public void delete(int index) {
if (index >= 0 && index < size()) {
// 定义新数组，长度是原始数组长度-1
Object[] dest = new Object[src.length - 1];
// 如果下标<index,则按下标位置拷贝
for (int i = 0; i < index; i++) {
dest[i] = src[i];
}
// index位置的值丢掉不需要拷贝
// >index的下标位置拷贝到新数组下标-1的位置
for (int i = index + 1; i < src.length; i++) {
dest[i - 1] = src[i];
}
// 将src指向新数组
src = dest;
} else {
System.out.println("指定的下标超出范围！！！");
}
}
/**
* 获得容器中元素个数的方法 容器中不为null的元素个数
*
* @return 返回元素的个数
*/
public int size() {
return len;
}
}
//测试
public class MainDemo {
public static void main(String[] args) {
// 在创建容器对象的时候，将泛型具体化
ArrayQueue<String> queue = new ArrayQueue<String>();
//获得系统时间
long t1 = System.currentTimeMillis();
for (int i = 0; i < 10; i++) {
queue.add("元素" + i);
}
queue.add("新元素");
long t2 = System.currentTimeMillis();
for (int i = 0; i < queue.size(); i++) {
String s = queue.get(i);
System.out.println(s);
}
System.out.println(Math.abs(t2-t1));
}
}
//上述的两个是对数据的存取速度进行比较，第二种的速度比第一种的开辟速度快很多
java的API中有一系列的方法可以供调用，例如：list set map等