数组

紫宇轩90

于 2014-01-15 23:04:19 发布

阅读量470

点赞数

分类专栏：原创

本文链接：https://blog.csdn.net/u013440955/article/details/18323431

版权

原创专栏收录该内容

13 篇文章 0 订阅

订阅专栏

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

好处：自动从0开始编号，方便操作。

格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr = newint[5];

格式2：元素类型[] 数组名 = new 元素类型[]{元素,元素,元素,...};

示例：int[] arr = newint[]{3,5,1,7};

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

注意：数组建立是必须明确长度。

Java内存空间的划分一共分为5块：

寄存器：CPU负责处理。

本地方法区：与所在系统相关，运行本地系统平台上的内容。

方法区：加载类中的方法，变量等。

栈内存：运行方法。

堆内存：对象的存放，有地址引用。

特点：

(1)每一个实体都有一个首地址。

(2)堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同，整数是0，小数是0.0或0.0f，boolean是false，char是’\u0000’。

(3)垃圾回收机制(释放堆内存)。

数组-常见问题

1，int[] arr = new int[3];

System.out.println(arrp[3]);

报错：ArrayIndexOutOfBoundsException;

当访问到数组不存在的角标时，就会产生这个异常。

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

arr= null;

System.out.println(arr[0]);

报错：NullPointerException

当引用变量没有任何实体指向时，还在用其操作实体，就会产生该异常。

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

System.out.println(arr);

打印出：[I@C17164

其中：

[:这个代表的是这个实体是一个数组。

I:代表这个数组的元素的类型是int型。

@:源码中用@作为连接两部分的符号。

17164:由windows用哈希算法算出的数组地址值，把二进制的值用十六进制表示。

数组的常见操作-遍历

1，对数组最基本的操作就是存和取。

存取的核心思想：对角标的操作。

2，用数组名.length 属性获取数组的长度。

3,对数组的遍历用循环语句，例如

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

System.out.println("length:" + arr.length);

for(int i=0;i<arr.length;i++)

{

System.out.println("arr[" + x + "] = " + arr[i]);

}

数组-最值：

class ArrayDemo

{

public static void main(String[] args)

{

int[] arr = {34,19,11,109,3,56};

int maxElement = getMax(arr);

System.out.println("max=" + maxElement);

}

}
获取数组中的最大值

思路：1，需要进行比较，并定义变量记录住每次比较后的较大的值

2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较，如果遍历到的元素大于变量中记录的元素，就用变量记录住最大的值。

3，遍历结束，该变量记录就是最大值

定义一个功能来实现

明确一：结果——是数组中的元素，int

明确二：未知内容——数组

//方法一：通过与数组中的第一个元素比较

public static int getMax(int[] arr)

{

int maxElement = arr[0];

for(int i=1;i<arr.length;i++)

{

if(arr[i] > maxElement)

{

maxElement = arr[i];

}

return maxElement;

}

//方法二：通过角标比较

public static int getMax_2(int[] arr)

{

int maxIndex = 0;

for(int i=1;i<arr.length;i++)

{

if(arr[i] > arr[maxIndex])

{

maxIndex = i;

}

return arr[maxIndex];

}

选择排序;

第一轮比较{34,19,11,109,3,56}

34比19大，这两个换位置，变为{19,34,11,109,3,56};

继续用第一个数比较，19比11大，换位置，变为{11,19,34,109,3,56};

继续用第一个数比较，11比109小，位置不变，{11,19,34,109,3,56};

继续用第一个数比较，11比2大，交换位置，变为{3,11,19,34,109,56};

继续用第一个数比较，3比56小，不变；

比较到了数组的最后一个元素，所以这次循环结束，下一次循环从第二个元素11遍历，找出最小的放到第二位上，如此往复，排序完成。

class ArrayDemo
{
//自定义打印数组的方法
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] + ",");
}
else
{
System.out.print(arr[i] + "]");
}
}
}
//主函数
public static void main(String[] args)
{
int[] arr = {34,19,11,109,3,56};
//未排序时打印一遍数组
printArray(arr);
//调用选择排序方法
selectSort(arr);
//排序后打印数组
printArray(arr);
}
//选择排序
public static void selectSort(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 ArraySortDemo
{
//主函数
public static void main(String[] args)
{
int[] arr = {34,19,11,109,2,56};
//未排序时打印一遍数组
printArray(arr);
//调用选择排序方法
selectSort(arr);
//排序后打印数组
printArray(arr);
}
//自定义打印数组的方法
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] + ",");
}
else
{
System.out.print(arr[i] + "]");
}
}
}
//方法一：
public static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-1-x;y++)
{
if(arr[y] > arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
//方法二：
public static void bubbleSort_2(int[] arr)
{
for(int x=arr.length-1;x>0;x--)
{
for(int y=0;y<x;y++)
{
if(arr[y] > arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
}

方法一中：

-1是为了避免角标越界。

-x是为了让外循环增加一次，内循环参数与比较的元素个数递减。

注意：用Arrays.sort(arr);语句直接可以将arr数组排序，在实际开发时使用这种方式

排序位置置换代码提取

由于要排序的数组是不确定的，数组中要交换的两个元素也是不确定的，所以这里定义了三个形参。

public static void swap(int[] arr,int a,int b)

{

int temp = arr[a];

arr[a] = arr[b];

arr[b] temp;

}

排序性能问题

此方法可以在排序时减少换位操作，提高效率。

for(int x=0;x<arr.length-1;x++)
{
int num = arr[x];
int index = x;
for(int y=x+1;y<arr.length;y++) {
/*
若前一个数比后一个数大，则把后一个数的值记录到num，
把角标记录到index，第一轮内循环结束后，执行一次交换。
*/
if(num > arr[y])
{
num = arr[y];
index = y;
}
}
if(index != x)
{
//调用上面的换位操作
swap(arr,x,index);
}

数组-查找

查找数组中的指定元素，返回索引。

class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = {4,1,5,7,3,8,2};
int index = getIndex(arr,8);
System.out.println("index = " + index);
}
/*
数组常见功能:查找
*/
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x] == key)
return x;
}
return -1;
}
}

折半查找

折半查找的前提是数组有序，无序数组只能用一般方法。

13 15 19 28 33 45 78 106

0 1 2 3 4 5 6 7

min mid max

mid=（0+7）/2=3；

arr[mid]==key false

if (key>arr[mid]

min=mid+1;

if(key<arr[mid]

max=mid_1;

mid=（max+min)/2=(4+7)/2=5;

//方法一
public static int halfSearch(int[] arr,int key)
{
int max,min,mid;
min = 0;
max = arr.length - 1;
while(min <= max)
{
mid = (max + min) >> 1;
if(key > arr[mid])
min = mid + 1;
else if(key < arr[mid])
max = mid - 1;
if(max < min)
return -1;
mid = (max + min) / 2;
}
return mid;
}
//方法二
public static int halfSearch_2(int[] arr,int key)
{
int max,mid,min;
min = 0;
max = arr.length - 1;
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;
}

进制转换(10-16进制)

public static void toHex(int num)
{
//因为每个数由4*8个二进制位组成，所以这里小于8
for(int x=0;x<8;x++)
{
//15的二进制为1111，num&15能把最后的4个二进制位得出来
int temp = num & 15;
if(temp > 9)
System.out.print((char)(temp - 10 + 'A'));
else
System.out.print(temp);
//整体右移4位，使下四个二进制位移到最后
num = num >>> 4;
}
}

进制转换-查表法

1，什么时候使用数组？

如果数组出现了对应关系，而且对应关系的一方是有序的数字编号，并作为角标使用。这时就必须要想到数组的使用。

可以将这些数据存到数组中，根据运算的结果作为角标直接去查数组中对应的元素即可。

这种方式可以称为查表法。

public static void toHex_2(int num)

{

if(num == 0)

{

//如果是0，则后面的程序没有输出结果，直接return就可以。

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[8];

//pos作为指针，指向最后一个元素的位置

int pos = arr.length;

while(num != 0)

{

int temp = num & 15;

//把算出的值从数组的最后一个元素位置开始倒着存

arr[--pos] = chs[temp];

num = num >>> 4;

}

System.out.println("pos = " + pos);

//从pos指针位置开始输出，避免前面出现太多空格

for(int x = pos; x<arr.length;x++)

{

System.out.println(arr[x]);

}

进制转换-整合

写一个程序，实现十进制到各种进制的转换。

class ArrayTest
{
public static void main(String[] args)
{
toHex(26);
toBinary(26);
toOctal(26);
System.out.println(Integer.toBinaryString(-6));
}
//十进制-->十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//十进制-->二进制
public static void toBinary(int num)
{
trans(num,1,1);
}
//十进制-->八进制
public static void toOctal(int num)
{
trans(num,7,3);
}
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)
{
i nt temp = num & base;
arr[--pos] = char[temp];
num = num >>> offset;
}
for(int x=pos;x<arr.length;x++)
{
System.out.println(arr[x]);
}
System.out.println();
}
}

查表法练习

使用查表法表示星期。

class ArrayTest
{
public static void main(String[] args)
{
String week = getWeek(4);
System.out.println(week);
}
/*使用查表法
星期
strings="abc";
int x=4;
*/
public static String getWeek(int num)
{
if(num > 7 || num < 1)
{
return "错误的星期";
}
String[] weeks = {"","星期一","星期二","星期三" ,"星期四","星期五","星期六","星期日",};
return weeks[num];
}
}

紫宇轩90

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组

概念：同一种类型数据的集合，其实就是一个容器。好处：自动从0开始编号，方便操作。格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = newint[5];格式2：元素类型[] 数组名 = new 元素类型[]{元素,元素,元素,...}; 示例：int[] arr = newint[]{3,5,1,7};
复制链接

扫一扫