数组
存储地址连续，数组只记录第一个比特点地址，后面+N代表第N个地址，任何数组都是从0开始的。
新建的数组每一个地址默认值为0，新建的数组并不是空的，而是满数据的，数组赋值只是值的覆盖，地址的确是连续的。
数组的声明
1.类型名称[] 变量名=new 类型名称[length];
2.类型名称[] 变量名={?,?,?};
3.类型名称[] 变量名=new 类型名称[]{?,?,?};
（在java当中允许数组的长度为0）
public static void main(String[] args) {
int[] arr = new int[3];
int[] brr = {1,2,3};
int[] crr = new int[]{1,2,3};
}
三种数组声明的方式有一个共同的特点:那就是一定事先声明数组的长度
之所以事先要声明数组的长度，是因为数组存储在我们的堆内存当中，而我们的堆内存开辟内存空间的大小是在初始化的时候就需要确定的，不能随便扩大和缩小。
基本使用
我们可以看出，该数组的地址是连续的，我们要想取到数据下面的值，我们可以直接通过数组的下标进行获取。
public class TestArray {
public static void main(String[] args) {
//创建一个数组
int[] arr = new int[3];
//获取数组的长度
int arrlength = arr.length;
System.out.println(arrlength);
//访问数组当中的元素：数组名【下标】 注意：下标从0开始，最大可取到长度 -1
int element0 = arr[0];
System.out.println("element0:"+element0);
//为数组当中的元素赋值
arr[0] = 99;
System.out.println("element0"+arr[0]);
arr[1] = 98;
arr[2] = 97;
for (int i = 0; i < arr.length; i++) {
System.out.println("arr length"+i+":" + arr[i]);
}
//创建数组的同时为数组当中的元素赋值
int[] arr1 = new int[] {90,58,5,15,9};
//获取数组的长度
System.out.println("arr length:"+arr1.length);
}
}
结论：数组在构建的时候需要给定长度，数组的长度是不可变得
数组的扩容
由于数组的长度是不可变的，那么就会给我们造成一个问题，既当我们给数组添加数据满了以后就不能在添加了
那么我们现在就来解决一下这个问题：解决数组长度不可变问题
解决思路：
我们只需要重新见一个数组，新的数组的长度是原来数组长度+1，然后将数组当中的值传递给新数组，老数组的句柄指向新数组的堆内存空间
public static void main(String[] args) {
//定义数组
int[] arr = new int[] {1,2,3};
//快速的查询出数组当中的元素
System.out.println(Arrays.toString(arr));
//要加入数组的目标元素
int dst = 10;
//创建一个数组，数组长度是原数组长度 + 1
int[] brr = new int[arr.length+1];
//数组当中的数据全部复制到新的数组当中去
for (int i = 0; i < arr.length; i++) {
brr[i] = arr[i];
}
//将目标元素放入到新数组的最后
brr[3] = dst;
//新数组替换元素组
arr = brr;
//快速的查询出数组当中的元素
System.out.println(Arrays.toString(arr));
}
for each循环
java有这一种很强的循环结构，可以用来依次处理数组当中的元素，不会产生越界问题。
public static void main(String[] args) {
List list = new ArrayList<String>();
for (int i = 0; i <10; i++) {
list.add("123");
}
for (Object object : list) {
System.out.println(object);
}
}
数组的插入
数组的插入和删除都需要移动数据元素，插入x作为第 i 个元素，首先必须将元素ai,ai+1…an-1向后移动，空出第 i 个元素，然后将 x 插入。如果数组，则不能插入，称为数组溢出 。解决数据溢出的办法是，申请一个更大容量的数组，并复制全部的数组元素，这样就扩充了顺序表得容量
申请更大容量的数组
public class ArrayInsert {
public static void main(String[] args) {
System.out.println("---请输入数组的长度---");
Scanner scanner = new Scanner(System.in);
int arrLength = scanner.nextInt();
int[] arr = new int[arrLength];
System.out.println("---输入0代表输入截止---");
int temp = 0; // 定义变量用与记录数组当中有多少数据
for (int i = 0; i < arr.length; i++) {
int value = scanner.nextInt();
if(value == 0) {
break;
}
arr[i] = value;
temp += 1;
}
//输出当前数组
System.out.println(Arrays.toString(arr));
System.out.println("----请继续输入 您所想要输入的值------");
int value = scanner.nextInt();
System.out.println("----请输入您想要插入的位置，您可以输入0-"+ temp +"的值");
int index = scanner.nextInt();
inset(arr, value, index, temp);
}
public static void inset(int[] arr,int value,int index,int temp) {
//判断index的位置是否在数组的范围内
if (index<=0 || index >temp) {
System.out.println("您的输入不在范围。。。。");
}else {
//判断数据是否已满
if (temp == arr.length) {
//满了就扩容
int[] brr = new int[arr.length * 2];
for (int i = 0; i < arr.length; i++) {
brr[i] = arr[i];
}
arr = brr;
}
//数据向后边移动
for (int i = arr.length-2; i >= index; i--) {
System.out.println(i);
arr[i+1] = arr[i];
}
arr[index] = value;
}
System.out.println(Arrays.toString(arr));
}
}
时间复杂度为O(n)
数组的删除
public class ArrayDelete {
public static void main(String[] args) {
System.out.println("---请输入数组的长度---");
Scanner scanner = new Scanner(System.in);
int arrLength = scanner.nextInt();
int[] arr = new int[arrLength];
System.out.println("---输入0代表输入截止---");
int temp = 0; // 定义变量用与记录数组当中有多少数据
for (int i = 0; i < arr.length; i++) {
int value = scanner.nextInt();
if(value == 0) {
break;
}
arr[i] = value;
temp += 1;
}
//输出当前数组
System.out.println(Arrays.toString(arr));
System.out.println("----请继续输入 您所想要删掉的值------");
int value = scanner.nextInt();
int index = 0; //查询出该值的位置
for (int i = 0; i < arr.length; i++) {
if (value == arr[i]) {
index = i;
delete(arr, value, index, temp);
}
}
}
public static void delete(int[] arr,int value,int index,int temp) {
//判断index的位置是否在数组的范围内
//判断删除的是否为第最后一个
if (temp == index+1) {
//如果是最后一个直接变为0
arr[index] = 0;
}else {
//数据向前边移动
for (int i = index; i < arr.length;i++) {
if (i == arr.length- 1) {
//如果是最后一个直接变为0
arr[i] = 0;
break;
}
arr[i] = arr[i+1];
}
}
System.out.println(Arrays.toString(arr));
}
}
时间复杂度为O(n)
有序数组的二分法查找
思路：
以及数组元素是按顺序排序的，value是我们要查询的数据，begin和end表示要查询子序列的范围
①：从子序列的中间位置mid开始比较。value和mid元素相等，则查找成功；否则根据value大小缩小查询范围，若value较小，则继续在子序列的前半段查找；反之继续在后半段查找
②：重复①，直到查询成功；当begin和end表示范围无效时，表示查询不成功
二分法的时间复杂度O(log2n)
public class ArrayBinarySearch {
public static void main(String[] args) {
//定义一个有序的数组
int[] arr = new int[100];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
binarySearch(arr, 40);
}
/***
*
* @param arr
* @param value
* @return 查询的次数
*/
public static int binarySearch(int[] arr,int value) {
System.out.println("****************使用二分法查找****************");
int mid = 0; // 检索的时候
int start = 0; //用start和end两个索引控制它的查询范围
int end = arr.length;
int count = 0;
for (int i = 0; i < arr.length; i++){
count++;
mid = (start + end) / 2;
if(arr.length - 1 == i){
System.out.println("抱歉，没有找到");
}else if (arr[mid] < value){
start = mid;
}else if (arr[mid] > value){
end = mid;
}else{
System.out.println(arr[mid] + "找到了，在数组下标为" + mid + "的地方,查找了" + count + "次。");
break;
}
}
return count;
}
}
有序数组的插入
public class OrdArray {
int[] arr = new int[10]; //定义一个数组
int flage = 0;//定义一个变量
//插入方法
public void insert(int value){
//判断是不是插满了
if(flage == arr.length) {
System.out.println("插满了，可以考虑扩容了");
return;
}
//需要判断flage是不是0
if(flage == 0) {
arr[flage] = value;
flage +=1;
}else{
//判断该值是不是必flage地址的当前的值大
if(value >arr[flage-1]) {
System.out.println("----------");
//插入
arr[flage] = value;
flage +=1;
}else {
//循环去判断该插入那个位置
for(int i=0;i<flage;i++) {
//找到第一个必value大的值，将他们依次往后移动
if(arr[i]>value) {
System.out.println(flage+"==============");
int temp = flage;
for (int j = 0; j <= flage - i; j++) {
arr[temp] = arr[temp-1];
temp --;
}
arr[i] = value;
flage ++;
break;
}
}
}
}
System.out.println(Arrays.toString(arr));
}
}
使用数组实现栈结构
public class StackDemo {
private int[] arr = new int[24];
private int flag = 0;
public void put(int x){
if(flag == arr.length){ //空间满了
int[] arrnew = new int[arr.length * 2];
for(int i = 0;i < flag;i++){
arrnew[i] = arr[i];
}
arr = arrnew;
}
arr[flag] = k;
flag++;
}
public void get(){
if(flag == 0){
System.out.println("没有数据");
return;
}
System.out.println(arr[flag - 1]);
flag--;
}
public void show(){
if(flag == 0){
System.out.println("没有数据");
return;
}
for(int i = 0;i < flag;i++){
System.out.println(arr[i]);
}
}
}
使用数组实现队列结构
public class QueueDemo {
private int[] arr = new int[24];
private int start = 0;
private int end = 0;
public void put(int x){
if(start - end = arr.length){
System.out.println("队列已满");
return;
}
arr[start % arr.length] = x;
start++;
}
public void get(){
if(end == start){
System.out.println("没有数据");
return;
}
System.out.println(arr[end % arr.length]);
end++;
}
}
6280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
