Java语法结构(数组篇)
Java语法结构之数组
一 1.1 数组的概念：
是同一种类型数据的集合，其实数组就是一个容器！里面装的东西都是同类型。
如同 装了一篮子鸡蛋，这篮子就是那容器。
1.1.1 数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
1.1.2数组的格式：
格式(1)：
元素类型 [ ]数组名 = new 元素类型 [元素个数或数组长度] ;
示例： int [] arr = new int [3]; 也可以写成： int arr[] = new int[3];
格式(2)
元素类型 []数组名 = new 元素类型 [ ]{元素1,元素2,…};
示例： int [] arr = new int []{1,2,3,4,5};
int[] arr = {3,3,5,6};//这是静态初始化格式
1.2 数组的内存结构
在程序运行时，需要在内存中分配空间，为了提高运算效率，java有对空间进行了不同区域的划分，每个区域都有其特定的处理数据的方式和管理内存的方式。
如：
栈内存：
用于存储局部变量，当数据使用完了以后，所占用的空间自动释放。
堆内存：
1，数组和对象，通过new建立的实例都存放在堆内存中；
2，每一个实体都有一个内存地址值；
3，实体中的变量都有默认初始化值；
4，实体在不被使用，会在不确定时间内被垃圾回收器回收。
另外还有：方法区，本地方法区，寄存器。
内存中的分配图：
1.3 数组常见问题
1.3.1 数组的角标越界异常(ArrayIndexOutOfBoundsException)
例子：
int[] arr = new int[3];
System.out.println(arr[3]);
//因为角标是从0开始，new出来的数组代表只有三个角标，但是需求打印的是arr[3]代表第四个角标，实际中没有，所以报异常。
1.3.2 数组的空指针异常(NullPointerException)
int[] arr = new int[3];
arr = null;
System.out.println(arr[1]);//因为数组已经指向null，相当于清零了，你再去找，就会报空指针异常。
1.4 数组的常见操作
(1)遍历就是获取数组中的元素，一般用for循环；
(2)数组中有一个属性可以直接获取到数组元素的个数，使用方法：“数组名.length”
下面是对数组的练习操作：
练习一：
/*
需求：给定一个数组{2,4,6,8,9,1}
获取其最大值和最小值。
*/
class GetMaxMin{
public static void main(String[] args) {
int[] arr = {2,4,6,8,9,1};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("最大值是："+max+"最小值是："+min);
}
public static int getMax(int[] arr){
//获取最大值
int max = arr[0];//定义变量用于记住相比较的值
//若比他大就赋值给他，在和下一个值比较直到比完。
for (int x = 0;x<arr.length ;x++ ){
if (arr[x]>max)
max = arr[x];
}
return max;
}
public static int getMin(int[] arr){
//获取最小值
int min = arr[0];//定义变量用于记住相比较的值
//若比他小就赋值给他，在和下一个值比较直到比完。
for (int x = 0;x<arr.length ;x++ ){
if (arr[x]<min)
min = arr[x];
}
return min;
}
}
对数组进行排序
练习二：
需求：给定数组，让其从小到大，或者从大到小排序
排序方式(一)：
选择排序
原理如图：
步骤：
1先定义一个变量记住比较后的值
2拿最前面的和后面的依次比较
3比较完成后遍历数组
class ChooseArray{
public static void main(String[] args) {
int[]arr = {2,5,3,8,6,33,55,11,44};
//排序前
printArray(arr);
//排序
getArray(arr);
//排序后
printArray(arr);
}
public static void getArray(int[] arr){
for (int x =0;x<arr.length-1 ;x++ )//外循环{
for (int y =x+1;y<arr.length ;y++ )//内循环{
if (arr[x]>arr[y])//若后面的比前面大就置换{
int a = arr[x];
arr[x] = arr[y];
arr[y] = a;
}
}
}
}
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]+",");
else
System.out.print(arr[x]+"]");
}
//换行
System.out.println();
}
}
练习三：
排序方式(二)
冒泡排序：
相邻的两个元素进行比较，若果符合条件就置换位置
原理图如下：
/*
冒泡排序
原理：
1，从头角标开始和相邻的元素进行比较，将较大值存放在变量中再进行下一个角标的元素比较，如此循环直到取得最大值。
2，每比较一次，存放较大或较小的数不进行比较，所以每次要减一
*/
class BubbleSort{
public static void main(String[] args) {
int[]arr = {2,5,3,8,6,33,55,11,44};
//排序前
sort(arr);
//排序
bubbleSort(arr);
//排序后
sort(arr);
}
public static void sort(int[] arr){
System.out.print("[");
for (int x=0;x<arr.length;x++) {
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
//换行
System.out.println();
}
public static void bubbleSort(int[] arr){
//冒泡排序;
for (int x = 0;x<arr.length-1 ;x++ ){
for (int y = 0;y<arr.length-x-1 ;y++ ){
if (arr[y]>arr[y+1]){
//int temp = arr[y];
//arr[y] = arr[y+1];
//arr[y+1] = temp;
swap(arr,y,y+1);
}
}
}
}
private static void swap(int[]arr,int x,int y)//位置置换功能抽取出来，因为内部使用所有私有化{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
数组的查找操作（一）
折半查找
/*
需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。
*/
class ArrayBinarySearch {
public static void main(String[] args) {
int[]arr = {1,3,4,6,7,11,21,33,44,51};
int jiaobiao1 = binarySeartch_1(arr,5);
int jiaobiao2 = binarySeartch_2(arr,5);
System.out.println("插入角标位置："+jiaobiao1);//用折半第一种方法
System.out.println("插入角标位置："+jiaobiao2);//用折半第二种方法
}
public static int binarySeartch_1(int[]arr,int key){
int min = 0, max = arr.length-1, mid = (min+max)/2;
while (key!=arr[mid]){
if(min>max)
return min;
else if (key>arr[mid])
min = mid+1;
else //if (key<arr[mid])
max = mid-1;
mid = (min+max)/2;
}
return mid;
}
public static int binarySeartch_2(int[]arr,int key){
int min = 0;
int max = arr.length-1,mid;
while (max>min){
mid = (min+max)>>>2;
if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid-1;
else
return mid;
}
return min;
}
}
使用查表法将十进制转换为二进制、八进制、十六进制
*
查表法原理：就是将所有需要的元素临时存储起来，然后建立对应关系
根据每次&15后的值作为索引查建立好的表，就可以找到对应的元素
这样就比 -10+'a'简单很多了。
*/
class ArrayText {
public static void main(String[] args) {
int num = 77;
toBin(num);//十转二
toBa(num);//十转八
toHex(num);//十转十六
}
public static void toBin(int num){
trans(num,1,1);
}
public static void toBa(int num){
trans(num,7,3);
}
public static void toHex(int num){
trans(num,15,4);
}
//定义工具进行进制转
private static void trans(int num,int yushu,int weiyi){
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){
arr[--pos] = chs[num&yushu];//将&后的字符倒着存储到临时数组中
num = num>>>weiyi; //再将传入的数右移相应的位数，再一次循环；
}
for (int x=pos;x<arr.length ;x++ )//将存储到arr数组中的数据取出{
System.out.print(arr[x]);
}
System.out.println();
return;
}
}
数组中的数组
1.1数组中的数组就是二维数组
格式1：int[][] arr = new int[3][2];
分析：
定义了名称为arr的二维数组；
二维数组里面有三个一维数组；
每个一维数组有两个元素；
一维数组的名称分别是arr[0], arr[1], arr[2];
若给一维数组的1角标添加元素77：arr[0][1] = 78;
格式2：int[][] arr = new int[3][0];
分析：
二维数组中有3个一维数组；
每一个一维数组的初始化值都是null；
可以对这三个一维数组分别进行初始化
arr[0] = new int[2];
arr[1] = new int[2];
arr[2] = new int[2];
/*
二维数组小练习
计算出该二维数组的总数：
int[][]arr = {{2,4,1,3,4,6,},{3,4,53,5,},{2,3,5,4,8,5}};
*/
class TwoArrayText{
public static void main(String[] args) {
int[][]arr =
{{2,4,1,3,4,6,},{3,4,53,5,},{2,3,5,4,8,5}};
int num = 0;
for (int x=0;x<arr.length ;x++ ){
for (int y=0;y<arr[x].length ;y++ ){
num = num+arr[x][y];
}
}
System.out.println(num);
}
}
打印结果是：112
642
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
