Java基础--数组

数组

一维数组

概念：同一种类型数据的集合，其实数组就是一个容器；

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素；

定义一维数组的格式：

元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]；

示例：int[ ] arr=new int[4];//数组元素不明确时用这种方式；指定角标的方式赋值:

arr[0]=3;

arr[1]=4;

arr[2]=5;

arr[3]=7;

元素类型[ ] 数组名=new 元素类型[ ]{元素1，元素2，元素3……}；

例：int[ ] arr=new int [ ]{3,4,5,7};//当元素内容明确时用这种方式

　　int[ ] arr={3,4,5,7};//这两种写法是等效的；

内存结构

Java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每片区域都有特定的处理数据方式和内存管理方式：

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放；

堆内存：

数组和对象都存放在堆内存中；

每个实体都内存地址值；

实体中的变量都有默认初始化值；

实体不再被使用，会在不确定的时间内被垃圾回收器回收；

方法区；

本地方法区；

寄存器；

注：

int[] arr=new int[5];

arr=null;//该语句表示数组arr指向为null、此时之前建立的数组不在被使用；

数组的属性之一：可以直接获取到数组元素的个数length

使用方式：数组名称.length；

例：打印某个数组的长度：

System.out.println(arr.length);

给数组中的元素排序；

数组排序可使用嵌套循环来完成；

选择排序



代码示例：

class SelectorSort
{
public static void selector(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 temp=arr[x];
arr[x]=arr[y];
arr[y]=temp
}
}
}
}
}

冒泡排序：相邻的两个元素进行比较，如果符合条件换位；



代码示例；

class BubbleSort
{
public static void bubbleSort(int[ ] arr)
{
for(int a=0;a<arr.length-1;a++)
{
for(int b=0;b<arr.length-a-1;b++)
{
if(arr[b]>arr[b+1])
{
int temp=arr[b];
arr[b]=arr[b+1];
arr[b+1]=temp;
}
}
}
}
}

开发中Java有排序功能：Arrays.sort(数组名);

查找

顺序查找（定义一个变量，遍历数组元素将对应值赋给变量）

折半查找：提高效率，但保证是有序的数组

import java.util.*;
class ArrayTest
{
public static void main(String[] args)
{
//      int[] arr = {3,2,1,5,4,2,9};
//      int index = getIndex(arr,2);
//      System.out.println("index="+index);

int[] arr = {2,4,5,7,8,19,32,45};//8

int index = getIndex_2(arr,190);
System.out.println("index="+index);
}
//int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
//System.out.println("x="+x);
public static int getIndex_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while(min<=max)
{
mid = (max+min)>>1;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return min;
}

/*
折半的第二种方式。
*/
public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;

while(min<=max)
{
mid = (max+min)>>1;

if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
/*
折半查找。提高效率，但是必须要保证该数组是有序的数组。
*/
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;

while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;

if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
}

进制转换

二进制转十进制、八进制、十六进制的通用方法：

class ArrayTest
{
public static void main(String[] args)
{
//toBin(-6);
//toHex(-60);
//toBa(60);
//      System.out.println(Integer.toBinaryString(6));
//      System.out.println(Integer.toHexString(6));
}
/*
十进制-->二进制
*/
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);
}
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]);
}
return ;
}
}

二维数组

格式一：

int[ ][ ] arr=new int[3][2];

定义了名称为arr的二维数组；

二维数组中有3个一维数组；

每个意为数组中2个元素；

一维数组的名称分别为arr[0],arr[1],arr[2];

给第一个一维数组1角标赋值为78的写法为：arr[0][1]=78;

格式二：

int[ ][ ] arr=new int[][];

二维数组中有3个一维数组；

每个一维数组都是默认初始化值为null；

可以对这三个一维数组分别进行初始化；

arr[0]=new int[3];//初始化二维数组的一维数组长度为3；

arr[1]=new int[1];

arr[2]=new int[2];

数组为引用数据类型，默认初始化值为null；

例：定义数组int[ ][ ] arr=new int[3][ ];

　　则：arr[0]=null;

arr.length为二维数组的长度；

二维数组的静态初始化方式：

int[][] arr={{3,4,5},{3,5},{1,4,8}};

数组的定义形式有多种：

一维数组的定义形式：

int[ ] x;等同于：int x[ ];

二维数组的定义形式：

int[ ][ ] y；等同于 int y[ ][ ];等同于 int[ ] y[ ];

综上所述：

　　int[ ] x,y[ ]；等同于int[ ] x；int[ ] y[ ];

　　即：x为一维数组，y为二维数组；