数组：
1.数组的存储内存地址是连续的
2.数据类型和长度是确定的
3.数组的每一个存储位置都有一个编号，叫做数组的索引或者下标，数组的下标是从0开始的连续整数
4.数组最大下标=数组长度-1
优点：数据是存放在一块连续的内存地址上查找效率高
缺点：在改变数据个数的时候[增加、插入、删除]的效率比较低
int [] a = new int [2] ; //将10存放到数组下标为0的位置 a [0] = 10; //将20存放到数组下标为1的位置 a [1] = 20;
int [] a = {10,20};
//获得数组中下标为1位置中的数
int t = a [1] ;
扫描二维码关注公众号，回复：
539243 查看本文章
int [] a = {10,20,30,40};
//获得数组的长度
int len = a.length;
链式列表：
[链表] 数据在内存中可以在任意位置，通过引用来关联数据。链表的大小可以按需要伸缩，是一种动态结构
优点：插入、删除灵活，结点可以插入到链表的任何位置都可以，而且不必移动结点中的指针。
缺点：在查找结点的时候，只能从第一个结点开始顺着链表逐个查找。
数组的使用场景：
/**
* 自定义长度可变的数组[泛型]
*
* @author Administrator
*
*/
public class MyArray<E>{
// 定义一个长度为0的初始数组
private Object[] src = new Object[0];
/**
* 增加数据
* @param s 要增加的数据
*/
public void add(E s) {
// 定义一个新数组长度是源数组长度+1
Object[] dest = new Object[src.length + 1];
// 将原数组的数据拷贝到新数组中
System.arraycopy(src, 0, dest, 0, src.length);
// 将新数据放到新数组的最后一个位置
dest[dest.length - 1] = s;
// 将原数组指向新数组
src = dest;
}
/**
* 取出数据
* @param index 要取出的数据的下标
*/
public E get(int index) {
Object s = src[index];
return (E) s;
}
/**
* 根据下标删除数据
* @param index 要删除的数据的下标
*/
public void delete(int index) {
//定义一个新的数组长度是源数组的长度-1
Object s [] = new Object [src.length-1];
//将下标小于index的拷贝到新数组对应的小标位置
System.arraycopy(src, 0, s, 0, index);
//将下标大于index的拷贝到新数组下标的位置为原数组的下标位置-1
System.arraycopy(src, index+1, s, index, src.length-index-1);
//将src指向新数组
src = s;
}
/**
* 删除指定的数据
* @param s 要删除的数据，如果有重复的数据，就删除下标最小的
*/
public void delete(E s) {
int t = -1;
for(int i=0; i<src.length; i++){
if(src[i].equals(s)){
t = i;
break;
}
}
//如果s在数组中出现过，t一定会大于等于0
if(t>=0){
delete(t);
}
}
/**
* 将数据插入到指定位置
* @param index 要插入的位置
* @param s 要插入的数据
*/
public void insert(int index, E s){
//定义一个新数组长度是原数组长度+1
Object str [] = new Object [src.length+1];
//将新数据放到新数组的指定位置
str [index] = s;
//将下标小于index的拷贝到新数组对应的下标位置
System.arraycopy(src, 0, str, 0,index);
//将下标大于等于index的拷贝到新数组下标+1的位置
System.arraycopy(src, index, str, index+1, src.length-index);
//将src指向新数组
src = str;
}
/**
* 修改数据
* @param index 要修改的数据的下标
* @param s 修改后的数据
*/
public void update(int index, E s) {
src[index] = s;
}
/**
* 获得数据个数
*/
public int size() {
return src.length;
}
}
public class Main {
public static void main(String[] args) {
MyArray2<Integer> m = new MyArray2<Integer>();
//增加数据
m.add(100);
m.add(200);
m.add(300);
m.add(400);
m.add(500);
m.add(600);
//按下标删除数据
m.delete(0);
//按内容删除数据
m.delete(new Integer(200));
//按下标修改数据
m.update(3, 400);
//按下标插入内容
m.insert(2, 300);
for(int i=0; i<m.size();i++){
int t = m.get(i);
System.err.println(t);
//输出结果：
//300
//400
//300
//500
//400
}
}
}
链表的使用场景：
/**
* 链式实现栈
* 单项链表
*/
public class zhan <E>{
//定义一个空链表
private Node<E> hean= null;
//结点个数
private int num = 0;
/**
* 将数据压入栈
* @param e 要压入的数据
*/
public void put(E e){
// 根据数据创建一个结点类
Node<E> node = new Node<E> (e);
// 如果链表中没有结点
if(hean==null){
hean = node;
}else{
// 将新的结点作为链表的头结点
node.next = hean;
// 将head执行新的头结点
hean = node;
}
num++;
}
/**
* 弹出栈顶的数据
* @return 返回弹出的数据
*/
public E poll(){
if(hean!=null){
// 定义一个变量指向原来的头结点
Node<E> n =hean;
//将hean的指向下一个结点
hean = hean.next;
// 将原来头结点的next指向null
n.next = null;
num--;
return n.data;
}
return null;
}
/**
* 返回栈的长度
* @return 数据的个数
*/
public int size() {
return num;
}
/**
* 判断栈是不是一个空栈
* @return 如果没有数据，就返回true，否则false
*/
public boolean isEmpty() {
return num == 0;
}
//递归
public void printData(Node<E> node){
if(node!=null){
System.out.println(node.data);
node = node.next;
printData(node);
}
}
}
//单向链表结点类
class Node<E>{
//结点的数据
E data;
//对下一个结点的引用
Node<E> next;
//创建结点对象的时候必须指定数据
public Node(E e){
this.data = e;
}
}
/**
* 链式实现栈的主类
* @author Administrator
*
*/
public class ZhanMain {
public static void main(String[] args) {
// 创建栈对象
zhan<String> z = new zhan<String>();
// 将数据压入栈
z.put("AA");
z.put("BB");
z.put("CC");
// 从栈中弹出数据
while (!z.isEmpty()) {
String s = z.poll();
System.out.println(s);
//输出结果：
//CC
//BB
//AA
}
}
}