目录 :
1 ) . 数组(概述--内存结构)
2 ) . 数组(静态初始化-常见问题)
3 ) . 数组(常见操作-遍历)
4 ) . 数组(常见操作--获取最值)
5 ) . 数组(排序--选择排序)
6 ) . 数组(排序--冒泡排序)
7 ) . 数组(排序--位置置换功能抽取)
8 ) . 数组(折半查找)
9 ). 数组(十进制,二进制)
10 ). 数组(十进制,十六进制)
11 ). 数组(查表法十进制,十六进制)
12 ). 数组 ( 查表法十进制,二进制)
13 ). 数组(进制转化优化)
14 ) . 数组(二维数组)
15 ). 数组(二维数组练习)
一
.
数组(概述--内存结构)
1 ) . 简述要点 :
1.1 数组的定义
[1] 概念 : 同一种类型数据的集合,其实数组就是一个容器,用来存数据的一种方式
[2] 好处 : 可以自动给数组中的元素从0开始编号,方便操作这些元素
[3] 格式 :
① 元素类型[] 数组名 = new 元素类型[元素个数或数组长度] 例 : int[] arr=new int[5];
② 元素类型[] 数组名 =new 元素类型[]{元素,元素,......}; 例 : int [] arr=new int[]{3,5,7}; int[] arr = {3,5,7};
1.2 数组的内存分配及特点
特点 : [1] 内存地址值, [2] 默认初始化值 -->依据类型而定,记住特殊的boolean是flase ,其它都是 0 / 0.0 , 0.0f 之类的即可 [3] 垃圾回收机制
1.3 数组操作常见问题
1.4 数组常见操作
1.5 数组中的数组
2 ) . 内存结构 -->Java程序运行时,需要在内存中分配空间,为了提高运算效率,有对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式
2.1 栈内存 --> 用于存储局部变量,当数据使用完,所占空间会自动释放
2.2 堆内存
[1] 数组和对象,通过new 建立的实例都存放在堆内存中
[2] 每一个实体都有内存地址值
[3] 实体中的变量都有默认初始化值
[4] 实体不在被使用,会在不确定的时候内被垃圾回收器回收 -->java的特点
2.3 方法区
2.4 本地方法区
2.5 寄存器
3 ) . 示例 :
int[] arr = new int[5]; --> 定义了一个名称为arr的数组,类型是int类型,并标识出了数组中的长度为7 -->定义了实体为arr,类型是int,标识数组长度为7
int[] arr =new int[]{1,2,3}; ---> 定义了一个名称为arr的数组,类型是int类型,通过大括号的形式标识出了数组中元素的内容为,1,2,3
4 ) . 数据不同定义格式的用法 :
4.1 数据明确时 : -->不标识长度
[1 ] int[] arr =new int[]{1,2,3};
[2] int[] arr ={1,2,3};
4.2 数据不明确时 : -->标识长度
[1] int[] arr = new int[5];
小结 :
1. 栈和堆之间的桥梁是进制地址数据,用来标识关系
二.
数组(静态初始化-常见问题)
1 ) . 静态初始化的方式 :
1.1 int[] arr =new int[]{1,2,3}; ---> 定义了一个名称为arr的数组,类型是int类型,通过大括号的形式标识出了数组中元素的内容为,1,2,3
1.2 int[] arr ={1,2,3}; --> 1.2 是 1.1 的简化形式
2 ) . 数组常见异常 :
2.1 ArrayIndexOutOfBoundsException : -->数组下标越界异常 : 操作数组时,访问到了数组中不存在的角标时出现
2.2 NullPointerException : --> 空指针异常 : 当引用没有任何指指向值或只为空时,该引用还在用于操作实体时出现
小结 :
1. int[] arr =new int[2]; 与 int arr[] =new int[2] ; 两者没有什么区别2. 数组中坐标从0开始
三.
数组(常见操作-遍历)
1 ) . 简述 : 遍历-->指对数组的操作 : 获取数组中的元素
属性 : length : 数组中用来获取数组元素个数 ;使用方式 : .length
2 ) . Demo示例 : 简单遍历
int[] arr=new int[]{1,2,3,4,5};for(int i=0;i<arr.length;i++){System.out.println("arr["+i+"]="+arr[i]);}
3 ) . 数组标准化输出格式 : --> //需求 : 定义一个用于打印数组中的元素,用逗号隔开
//需求 : 定义一个用于打印数组中的元素,用逗号隔开public static void printArray(int[] arr){System.out.print("[");
for(int x=0;x<arr.length;x++){if(x!=arr.length-1)System.out.print(arr[x]+", ");elseSystem.out.print(arr[x]+"]");}}
小结 :
1. 通过length动态获取数组长度,以此动态遍历
四.
数组(常见操作--获取最值)
1 ) . 案例详解 : 功能方法 :
//需求 : 获取数组当中的最大值,最小值//思路 : 需要一个临时变量存储第三方变量,而后一对一做比较,并记录住最大值的那个//实践 ://1. 未知参数 : 一个数组 int[]//2. 返回类型 : 是一个int类型的返回类型//方式一 : 通过初始化数组中任意一个元素的方式public static int arrayMax(int[] arr){int max=5;for(int i=1;i<arr.length;i++){if(arr[i]>max)max=arr[i];}return max;}public static int arrayMin(int[] arr){int min=5;for(int i=1;i<arr.length;i++){if(arr[i]<min)min=arr[i];}return min;}//方式二 : 通过初始化数组角标public static int arrayMax_2(int[] arr){int max=0;for(int i=1;i<arr.length;i++){if(arr[i]>arr[max])arr[max]=arr[i];}return arr[max];}public static int arrayMin_2(int[] arr){int min=0;for(int i=1;i<arr.length;i++){if(arr[i]<arr[min])arr[min]=arr[i];}return arr[min];}
2 ) . main方法 :
class ArrayDemo{public static void main(String[] args){
int max = arrayMax(arr);int max2 = arrayMax_2(arr);System.out.println("max第一种获取最大值初始化方式结果:"+max);System.out.println("max第二种获取最大值初始化方式结果:"+max2);int min = arrayMin(arr);int min2 = arrayMin_2(arr);System.out.println("min第一种获取最大值初始化方式结果:"+min);System.out.println("min第二种获取最大值初始化方式结果:"+min2);
}
}
小结 :
1. 用数组获取最大值最小值一般用在数值类型的属性时,若boolean类型,则默认是false
五
.
数组(排序--选择排序)
1 ) . sortDemo :
class ArraySort{public static void main(String[] args){//需求 : 选择排序int[] arr={1,4,2,7,4,6,23,45,322,45};//排序前printArray(arr);//排序getArraySort(arr);//排序后printArray(arr);}//定义一个排序的函数//1.明确返回值还是原数组,因此没有返回类型//2.需传入一个数组public static void getArraySort(int[] arr){//这里长度减1是因为最后一个值无需比较for(int i=0;i<arr.length-1;i++){//这里i+1是因为一前一1后进行比较for(int j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}}}}public static void printArray(int[] arr){System.out.print("[");for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+", ");elseSystem.out.println(arr[i]+"]");}}}
2 ) . 特点 : 内循环结束一次,最值出现在头角标的位置上
小结 :
1. 选定一个固定点,依次与其他定点逐个比较的方式是选择排序2. 堆内存中可以有多个引用,一个实体的存在
3. 排序的核心是只要谨记上条件下初始值即可通过正倒三角实现完成
六.
数组(排序--冒泡排序)
1 ) . 简述 : 相邻的两个元素进行比较,若如何条件则换位
2 ) . 特点 : 内循环结束一次,最值出现在最后位标的位置上
3 ) . boobbleSort :
class bubbleSort{public static void main(String[] args){//需求 : 冒泡排序int[] arr={1,4,2,7,4,6,23,45,322,45};//排序前printArray(arr);//排序getBubbleSort(arr);//排序后printArray(arr);}//定义一个排序的函数//1.明确返回值还是原数组,因此没有返回类型//2.需传入一个数组public static void getBubbleSort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int y=0; y<arr.length-i-1;y++) //-i 指让每一次比较的元素减少 -1 指避免角标越界{if(arr[y]>arr[y+1]){int temp=arr[y];arr[y]=arr[y+1];arr[y+1]=temp;}}}}public static void printArray(int[] arr){System.out.print("[");for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+", ");elseSystem.out.println(arr[i]+"]");}}} class bubbleSort{public static void main(String[] args){//需求 : 冒泡排序int[] arr={1,4,2,7,4,6,23,45,322,45};//排序前printArray(arr);//排序getBubbleSort(arr);//排序后printArray(arr);}//定义一个排序的函数//1.明确返回值还是原数组,因此没有返回类型//2.需传入一个数组public static void getBubbleSort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int y=0; y<arr.length-i-1;y++) //-i 指让每一次比较的元素减少 -1 指避免角标越界{if(arr[y]>arr[y+1]){int temp=arr[y];arr[y]=arr[y+1];arr[y+1]=temp;}}}}public static void printArray(int[] arr){System.out.print("[");for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+", ");elseSystem.out.println(arr[i]+"]");}}}
4 ) . 排序的基本原理就是相互比较,只是比较的方式不同罢了
小结 :
1. 排序方式最快的是希尔排序,三层循环加位移运算的排序2. 排序方式效率越高意味着在堆内存置换的次数就越少,大多数在堆内进行了临时存储
七.
数组(排序--位置置换功能抽取)
1 ) . 前言 : 经选择排序和冒泡排序,发现其中的共性代码是位置置换,因此可以提取成一个单独的函数存在
2 ) . swap :
class bubbleSort{public static void main(String[] args){//需求 : 冒泡排序int[] arr={1,4,2,7,4,6,23,45,322,45};//排序前printArray(arr);//排序getBubbleSort(arr);//排序后printArray(arr);}//用来置换public static void getSwap(int[] arr,int a,int b){int temp=arr[a];arr[a]=arr[b];arr[b]=temp;}//定义一个排序的函数//1.明确返回值还是原数组,因此没有返回类型//2.需传入一个数组public static void getBubbleSort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int y=0; y<arr.length-i-1;y++) //-i 指让每一次比较的元素减少 -1 指避免角标越界{if(arr[y]>arr[y+1]){//置换代码getSwap(arr,y,y+1);/*int temp=arr[y];arr[y]=arr[y+1];arr[y+1]=temp; */}}}}public static void printArray(int[] arr){System.out.print("[");for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+", ");elseSystem.out.println(arr[i]+"]");}}}
3 ) . 要点 :
3.1 Arrays.sort(arr); --> 该句是java中定义好的一种排序方式,开发中, 对数组排序时使用
小结 :
1. 分清楚要传的参数列表是什么,也需明白想要的结果是什么
八
.
数组(折半查找)
1 ) . 简述 : 折半查找是最快的以减半的方式缩小范围查找,前提是有序的
2 ) . HalfSearch示例 :
class ArrayFind{public static void main(String[] args){//需求 : 折半查找// int[] arr={1,4,2,7,4,6,23,45,322,45};int [] arr={1,2,3,4,5,6,7,8,9,20,23};int index= halfSearch(arr,6);int index2= halfSearch_2(arr,20);System.out.print("halfSearch折半第一次下标是 : "+index);System.out.print("halfSearch折半第二次下标是: "+index2);}//需求 : 进行折半查找的功能编写//1.返回值应该是int//2.参数列表是数组和数值//折半查找的第一方式public static int halfSearch(int[] arr,int num){int min=0;int max=arr.length-1;int mid=(min+max)/2;while(arr[mid]!=num){if(num>arr[mid]){min=mid+1;}else if(num<arr[mid]){max=max-1;}if(max>min)return -1;mid=(min+max)/2;}return mid;}//折半查找的第二方式public static int halfSearch_2(int arr[] ,int num){int min=0,max=arr.length,mid;while(min<=max){mid=(min+max)>>1;if(num>arr[mid])min=mid+1;else if(num<arr[mid])max=mid-1;elsereturn mid;}return -1;}//需求 : 需要一个传入数值便可或许下标的函数//1.返回值是int//2.参数列表是 数组和 数值//定义功能 : 获取key第一次出现在数组中的位置,如果返回是-1,那么代表该key在数组中不存在/* public static int getIndex(int[] arr,int num){for(int i=0;i<arr.length;i++){if(arr[i]==num)return i;}return -1;}*/}
3 ) . 小心得 : 折半查找是通过折中的方式,不断除以二以寻找到中间值
4 ) . 思考题 : 如何往有序数组中插入一条数据,并保证在插入后,这个数组还有有序的?
解答 : 可以通过折半查找的方式,先判断该数据在数组中是否已存在,若存在,则获取其位置的角标值,在该值后插入即可;若不存在,则获取其最小min值,在该值处插入即可
小结 :
1.在数组中, -1 可用来代表角标不存在或者数不存在
九
.
数组(十进制,二进制)
1 ) . 十进制转二进制对于计算机而言就是%2 与 /2的循环 ,详细见下边2 ) . 练习 :
2.1 基础练习题--> 十进制-->二进制的Demo
class ArrayText{public static void main(String[] args){tobin(10);}//需求 : 十进制-->二进制public static void tobin(int num){StringBuffer sb = new StringBuffer(); // 可以用来装数据的容器while(num!=0){sb.append(num%2);num=num/2;}System.out.println(sb.reverse());}}
小结 :
1. 先 %2 ,再 /2 ,然后循环即可
十.
数组(十进制,十六进制)
1 ) . 十进制转十六进制思路 : 十进制 -->二进制-->十六进制
1.1 二进制转十六进制的思路 : 记得 四位 是一组
1.2 十进制转十六机制 先 &上15(十六进一)得出二进制第一组(四位一组)的十六进制数,而后再右移(无符号右移)>>>推上来的 第一组二进制数 再 进行&15 得出这一组的十六进制数
2 ) . 代码实现 :
//需求 : 十进制-->十六进制public static void toHex(int num){StringBuffer sb = new StringBuffer();//循环8是因为int类型是32位,每四位转化一次
for(int i=0;i<8;i++){int temp=num&15;
//判断是否大于九是因为十六进制10以后是字母表示if(temp>9)
sb.append((char)(temp-10+'A'));//转化为字符elsesb.append(temp);num=num>>>4;}
System.out.println(sb.reverse());}
小结 :
1. 先 & ,再 判断值 是否大于9 ,然后再无符号右移4位>>> ,循环即可
十一.
数组(
查表法
十进制,十六进制)
1 ) . 十进制-->十六进制
//需求 : -->十进制-->十六进制完整可负数的版本public static void toHex(int num){//建立临时容器char[] chs={'1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//使用char数组存储char[] arr= new char[8];//使用指针的方式获取值int pos=arr.length;//循环8是因为int类型是32位,每四位转化一次while(num!=0){int temp=num&15;//--pos意思是 倒着存入arr[--pos] = chs[temp];//转化为字符num=num >>> 4;}for(int x=pos;x<arr.length;x++){System.out.print(arr[x]);}}
2 ) . 以上代码难点在于倒着存储值,带给我的思考是借力使力不费力
小结 :
1. \u0000 -->这是一个空位
十二
.
数组
(
查表法
十进制,二进制)
1 ) . 十进制-->二进制
//需求 : 十进制-->二进制 (查表法)public static void tobin(int num){//定义一个二进制的表char[] ch ={'1','0'};//定义一个临时存储器char[] arr=new char[32];//定义一个操作数组的指针int pos=arr.length;//用来循环转化二进制数while(num!=0){//规律所得,你可以写下来尝试看看int temp=num & 1;arr[--pos]=ch[temp];num=num>>>1;}for(int x=pos;x<arr.length;x++){System.out.print(arr[x]);}}
小结 :
1. 不明觉厉,用下标去查数,用>>>无符号右移,用临时存储器存储查出来的值,用指针使得在哪里开始插入
十三
.
数组(进制转化优化)
1 ) . 进制之间的共性抽取,转化,优化的过程
class ArrayTance{public static void main(String[] args){toHex(60);}// 十进制-->十六进制public static void toHex(int num){trans(num,15,4);}//十进制-->八进制public static void toOct(int num){trans(num,7,3);}//十进制-->二进制public static void toBin(int num){trans(num,1,1);}public static void trans(int num,int base,int offset){if(num==0){System.out.println(0);return;}//定义一个二进制的表char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//定义一个临时存储器char[] arr=new char[32];//定义一个操作数组的指针int pos=arr.length;while(num!=0){int temp=num&base;arr[--pos]=chs[temp];num = num >>> offset;}for(int x=pos;x<arr.length;x++){System.out.print(arr[x]);}}}
2 ) . 对相关共性进行抽取时先采用参数列表的形式进行抽取,然后对具体函数值进行抽取,而后罗列成新的参数列表
3 ) . 前提是三者返回的参数类型是统一的
小结 :
1. 高内聚低耦合,A-->B-->C : 使用者-->第三方-->提供者
十四.
数组(二维数组)
1 ) . 简述 : int[] [] arr =new int[3][4]; --> 定义了名称为arr的二维数组,二维数组中有3个一维数组,每一个一维数组中有四个元素
2 ) . 格式 :
2.1 int[][] arr =new int[3][2];
[1] 定义了名称为arr的二维数组
[2] 二维数组中有3个一维数组
[3] 每一个一维数组中有两个元素
[4] 一维数组的名称分别为arr[0],arr[1],arr[2]
[5] 给第一个一维数组1脚标位赋值为78写法是 : arr[0][1] =78
2.2 int[] [] arr= new int[3][];
[1] 二维数组中有3个一维数组
[2] 每个一维数组都是默认初始化值null
[3] 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
3 ) . 数组的应用
3.1 数组的格式明显是大圈套小圈,毫不犹豫的进行for循环
int [] [] arr={{1,2,3},{1,5,3},{5,3,2}};int sum=0;for(int x=0;x<arr.length;x++){for(int y=0;y<arr[x].length;y++){sum+=sum+arr[x][y];}}System.out.println("sum"+sum);
小结 :
1. 我们可通过打印空的arr ,而后会得到地址,从地址判断是否是二维数组2. 引入类型的初始化值都是null
3. 在堆中只要开辟了空间,然后再进行赋值,那么对方调用方式就是指定引用地址,而非完全赋值元素内容
4. 二维数组可以对关系进行有效的分类
十五.
数组(二维数组练习)
1 ) . 一维数组格式 :
[1] int [] x;
[2] int x [];
2 ) . 二维数组格式 :
[1] int[] [] y ;
[2] int y[] [];
[3] int[] y [];
3 ) . int[] x, y[] ; //x一维 , y二维
小结 :
1. 一维可以赋给二维,但二维不可赋给一维,前提是分清一维和二维
1969
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
