数据类型和链表结构

						数据类型和链表结构

一：基本的数据结构
数据结构是计算机对数据存储的一种安排。
2. 存储数据的方式：
基本类型：
int a =10；
存储数据的方式单一，依次只能存储一个值。
值和类型匹配问题：数据类型限定了变量可以存储的数据类型
成员变量和局部变量问题：在使用局部变量之前，必须赋值
成员变量有默认值. 但是默认值都没有多大意义，在做项目的时候，给它赋一些值.
引用类型数组：
数组的声明格式： 数组中元素的类型[] 数组名
比如说 int[] ages = new int[3]
数组的作用：可以存储多个数据；
数组操作：存值 ages[0] = 10，取值 ages[0]
特点：长度固定，只能够是存储同种类型；
Interget i=10；
Integer类 里面有个int value 变量存储值,
String类 里面有个 char[] value 字符数组变量存储值.
自动装箱，可以把基本数据类型包装起来，可以通过包装去调用方法转换类型。
3 自定义容器类
目的：自定义容器类的作用是为了满足可以存放不同类型的长度，和任意类型的值。

① 定义一个自定义容器类 IntArray
② 创建一个存放数据的数组 比如 int[] data= new int[10];
③ 定义一个添加方法 add ，调用一次给当前容器对象添加一个元素
④ 创建自定义容器类对象，调用add方法，添加元素
自定义容器类的增删改查
//自定义的容器类增加元素：
/**

• v1.0
• 1.定义一个字段（固定类型），装用户传过来的数据

•   固定类型 -int
  

•   固定长度-10
  

• 2.对外提供一个方法 用来添加数据

•   每次都会覆盖   定义一个字段记录添加数据的位置
  

•   data[size++]=i; 解决方案
  

*/
public class list {
private int[] arr=new int[10]; //创建一个动态数组
public int size=0; //定义一个计数器
public void add(int c){ //对外一个一个方法
arr[size]=c; //这个存放的长度由用户调用的次数依次存储
size++;
}
@Override
public String toString() {
return “list [arr=” + Arrays.toString(arr) + “]”;
}

}
测试：
public class list1 {
public static void main(String[] args) {
list t1 = new list();
t1.add(4);
t1.add(6);
t1.add(7);
System.out.println(t1);
//list [arr=[4, 6, 7, 0, 0, 0, 0, 0, 0, 0]]
}
}
这儿我们为了美观去掉后边的几个0；进行追加的方法：
v2.0

• 目前打印的结果：DataList [data=[1, 2, 2, 2, 2, 0, 0, 0, 0, 0]]
• 期望的结果：添加多少数据就是打印多少数据
• 方案一：循环遍历+拼接字符串
• 方案二：System.arraycopy(data, 0, temp, 0, size);

*修改tostring方法
*/public String toString() {
int[] temp=new int[size];
System.arraycopy(arr, 0, temp, 0, size);
return “list [arr=” + Arrays.toString(arr) + “]”;
}
}
测试：
public static void main(String[] args) {
list t1 = new list();
t1.add(4);
t1.add(6);
t1.add(7);
//t1.add(7); //报错，过长
System.out.println(t1);
}
}
3超过存储长度自动扩容
*v3.0

• 长度可以发生改变
• 对于使用者：有两种情况

•  1.知道有多少个数据
  

•  	提供一个构造方法 传入 size 用于创建容器的长度
  

•  		可以自动扩容--长度增加的方案--倍数、 每次固定长度增长、百分比（推荐）
  

•  		1.数组已经被定义了   -重新定义一个数组（长度扩容后）
  

•  		2.要原来的数据里面的数据拷贝过去
  

•  		3.把新的数组的地址给data
  

•  2.不知道要放多少个数据
  

•  	提供一个无参数构造方法 默认创建一个长度为10的数组
  

*/
public class list {
private int[] arr=new int[3]; //创建一个动态数组
public int size; //定义一个计数器
//无参构造器给对象创建一个长度
public list(){
arr=new int[7];
}
//有参构造器通过用户传入的数据来决定长度；
public list(int length){
arr=new int[length];
}
//在提供一个共外界查看的size传入参数的长度
public int size(){
return size;
}
public void add(int c){
if(size==arr.length){ //先判断一下size用户传入的参数是否已经达到原来数组的长度了，如果是的话我们就给他扩容
int[] temp=new int[(size+1)*2]; //扩容的话添加到一个新的数组里边
System.arraycopy(arr, 0, temp, 0, size);
arr=temp;
}

	arr[size]=c;			//这个存放的长度由用户调用的次数依次存储
	size++;
}
@Override
public String toString() {
	int[] temp=new int[size];
	System.arraycopy(arr, 0, temp, 0, size);
	return "list [arr=" + Arrays.toString(arr) + "]";
}

}
测试：
public static void main(String[] args) {
list t1 = new list(10); //传入一个9的话就报错，传入数组过长了，怎么解决？
t1.add(4);
t1.add(6);
t1.add(7);
t1.add(6); //Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
t1.add(7); //报错，过长,存不下了怎么解决？
t1.add(7);
//System.out.println(t1); //java.lang.ArrayIndexOutOfBoundsException: 7
System.err.println(t1.size()); //看到了我的传入的长度为多少
System.err.println(t1);
}
}
4可以存放任意类型：
v4.0 ：最终版

•  类型的问题--Object
  

•  把int 换成Object
  

*public class list {
private Object[] arr; //创建一个动态数组
public int size; //定义一个计数器
//无参构造器给对象创建一个长度
public list(){
arr=new Object[7];
}
//有参构造器通过用户传入的数据来决定长度；
public list(int length){
arr=new Object[length];
}
//在提供一个共外界查看的size传入参数的长度
public int size(){
return size;
}
public void add(Object c){
if(size==arr.length){ //先判断一下size用户传入的参数是否已经达到原来数组的长度了，如果是的话我们就给他扩容
Object[] temp=new Object[(size+1)*2]; //扩容的话添加到一个新的数组里边
System.arraycopy(arr, 0, temp, 0, size);
arr=temp;
}

	arr[size]=c;			//这个存放的长度由用户调用的次数依次存储
	size++;
}
@Override
public String toString() {
	Object[] temp=new Object[size];
	System.arraycopy(arr, 0, temp, 0, size);
	return "list [arr=" + Arrays.toString(arr) + "]";
}

}
测试：
public class list1 {
public static void main(String[] args) {
list t1 = new list(10); //传入一个9的话就报错，传入数组过长了，怎么解决？
t1.add(4);
t1.add(6);
t1.add(7);
t1.add(6); //Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
t1.add(7); //报错，过长,存不下了怎么解决？
t1.add(“sasdasdasdas”);
//System.out.println(t1); //java.lang.ArrayIndexOutOfBoundsException: 7
System.err.println(t1.size()); //看到了我的传入的长度为多少
System.err.println(t1);
}
}
v1.0 1.定义一个字段（固定类型），装用户传过来的数据 固定类型 -int 固定长度-10 2.对外提供一个方法 用来添加数据 每次都会覆盖

• 定义一个字段记录添加数据的位置 data[size++]=i; 解决方案 v2.0 目前打印的结果：DataList [data=[1, 2, 2, 2,
• 2, 0, 0, 0, 0, 0]] 期望的结果：添加多少数据就是打印多少数据 方案一：循环遍历+拼接字符串
• 方案二：System.arraycopy(data, 0, temp, 0, size);

** v3.0 长度可以发生改变 对于使用者：有两种情况 1.知道有多少个数据 提供一个构造方法 传入 size 用于创建容器的长度

• 可以自动扩容–长度增加的方案–倍数、 每次固定长度增长、百分比（推荐） 1.数组已经被定义了 -重新定义一个数组（长度扩容后）
• 2.要原来的数据里面的数据拷贝过去 3.把新的数组的地址给data 2.不知道要放多少个数据 提供一个无参数构造方法 默认创建一个长度为10的数组
• v4.0 ：最终版 类型的问题–Object 把int 换成Object 1.数据的查找 a.根据索引位置找数据 b.查找数据第一次出现的索引
• 2.数据删除（最难）
• 3.修改（最简单） a.根据索引该数据

*/
public class list {
private Object[] arr; // 创建一个动态数组
public int size; // 定义一个计数器
// 无参构造器给对象创建一个长度

public list() {
	arr = new Object[7];
}

// 有参构造器通过用户传入的数据来决定长度；
public list(int length) {
	arr = new Object[length];
}

// 在提供一个共外界查看的size传入参数的长度
public int size() {
	return size;
}

public void add(Object c) {
	if (size == arr.length) { // 先判断一下size用户传入的参数是否已经达到原来数组的长度了，如果是的话我们就给他扩容
		Object[] temp = new Object[(size + 1) * 2]; // 扩容的话添加到一个新的数组里边
		System.arraycopy(arr, 0, temp, 0, size);
		arr = temp;
	}
	arr[size] = c; // 这个存放的长度由用户调用的次数依次存储
	size++;
}

// a.根据索引位置找数据 //查找
public Object getIndex(int index) { // 传入的数据有要求的
	if (index > 0 || index > size - 1) { // 为什么减1
		throw new NullPointerException("空指针异常");
	}
	return arr[index];
}

// b.查找数据第一次出现的索引 //查找
public Object getOb(Object obj) {
	// 循环我的数组依次比对数据
	for (int a = 0; a < size; a++) {
		if (obj.equals(arr[a])) {
			return a;
		}
	}
	return -1;
}

// a.根据索引数据 //删除指定索引
public void updata(int index, Object obj) {
	//  
	if (index < 0 || index > size - 1) {//
		throw new ArrayIndexOutOfBoundsException("参数不合法！");
	}
	arr[index] = obj;
}
// a.根据索引该数据
public void  deleteByIndex(int index){
	if (index < 0 || index > size - 1) {
		throw new ArrayIndexOutOfBoundsException("参数不合法！");
	 }
	//										
	System.arraycopy(arr,index+1 , arr, index,size-1-index);
	size--;
}
@Override
public String toString() {
	Object[] temp = new Object[size];
	System.arraycopy(arr, 0, temp, 0, size);
	return "list [arr=" + Arrays.toString(arr) + "]";
}

}
数据结构：链表结构
变量：存储一个值;
数组：存储多个值;
自定义容器类: 在类中封装一个数组；
![在这里插入图片描述](https://img-