数组的定义
1> 概念
同一种类型数据的集合。其实数组就是一个容器。
2> 数组的好处
可以自动给数组中的元素从0开始编号，方便操作这些元素。
3> 格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
---new 用于创建数组的关键字，在堆里开辟空间,如果：int[] att = arr; 那么arr att 都指向新开辟空间，如果定义 arr=null；的话表明把数组arr与实体空间断开连接，不影响att.
格式2：
元素类型[] 数组名 =new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7}; //既明确了元素的个数又明确了元素的内容.
//获取数组元素格式的方式. 数组名.length
System.out.println("len:"+arr.length);
数组的内存结构
内存结构
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存
1> 用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存
1> 数组和对象，通过new建立的实例都存放在堆内存中。
2> 每一个实体都有内存地址值
3> 实体中的变量都有默认初始化值，不同类型初始值不同。int 0, double 0.0,char \u000,boolean false.
4> 实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区，本地方法区，寄存器
数组操作常见问题
1> 数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[3]); //编译时没有问题，运行时才去找实体，所以运行时才会报错.
访问到了数组中的不存在的脚标时发生。
2> 空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。
数组常见操作
1> 获取最值(最大值，最小值)
2> 排序(选择排序，冒泡排序)
3> 折半查找(二分查找)
~~~~~~~~~~~~~~~~~获取最值~~~~~~~~~~~~~~~~~~~~~
class ArrayDemo3
{
public static void main(String[] args)
{
/*
常见的数组的操作：
1，获取元素。遍历。
*/
int[] arr = {34,15,617,22,19,88};
// for (int x = 0; x<arr.length ; x++)
// {
// System.out.println("arr["+x+"] = "+arr[x]+";");//arr[0] = 34;
// }
// 测试最大值。
int max = getMax2(arr);
System.out.println("max="+max);
}
/*
2，获取最大值。
思路：
1，定义一个变量。
2，遍历数组，让每一个元素和该变量中的数据进行比较。
3，改变量每一次记录较大的值。遍历结束，该变量中存储的就是最大值。
*/
/*
需求：定义一个获取整数数组最大值的功能。
明确1：有结果吗？有，整数。最大值。
明确2：有未知内容吗？有，数组。
*/
public static int getMax(int[] arr)
{
//1,定义变量，记录较大的值。
int max = arr[0];//初始化是数组中的任意一个元素
//2,遍历数组。
for (int x=1; x<arr.length ;x++ )
{
//3,进行判断比较。
if(arr[x]>max)
max = arr[x];
}
return max;
}
//第二种最大值。
public static int getMax2(int[] arr)
{
int maxIndex = 0;//初始化为数组中任意一个角标。
for (int x=0; x<arr.length ;x++ )
{
if(arr[x]>arr[maxIndex]){
maxIndex = x;
}
}
return arr[maxIndex];
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~排序~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import java.util.*;
class ArrayDemo4
{
//将数组变成字符串。
public static String arrToString(int[] arr)
{
String temp = "";
for (int x=0; x<arr.length ; x++)
{
if(x!=arr.length-1)
temp = temp+arr[x]+",";
else
temp = temp+arr[x];
}
return temp;
}
public static void main(String[] args)
{
int[] arr = {23,16,78,44,19,51};
System.out.println("排序前：");
String str = arrToString(arr);
System.out.println(str);
//selectSort(arr);
//bubbleSort(arr);
Arrays.sort(arr);//开发时常用的动作，java提供的已有的排序方式。
System.out.println("排序后：");
String str1 = arrToString(arr);
System.out.println(str1);
}
/*
选择排序。
*/
public static void selectSort(int[] arr)
{
//1，定义外循环，确定参与比较的元素。
for (int x=0; x<arr.length-1 ;x++)
{
for(int y=x+1; y<arr.length; y++)
{
//判断前一个大于后一个，就进行位置置换。
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
/*
冒泡排序。
*/
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])
swap(arr,y,y+1);
}
}
}
//对数组元素进行位置置换。
public static void swap(int[] arr,int index1,int index2)
{
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
}
~~~~~~~~~~~~~~~~~~~~二分查找~~~~~~~~~~~~~~~~~~~~~~
import java.util.*;
class ArrayDemo5
{
public static void main(String[] args)
{
// int[] arr = {34,1,76,99,32};
// int index = searchIndex(arr,9);
//定义有序的数组。
int[] arr = {12,16,22,45,78,89,99};
int index= getIndex3(arr,78);
// int index = Arrays.binarySearch(arr,80);//开发中使用的二分查找。
System.out.println("index="+index);
}
/*
数组中的元素的查找。获取元素第一次出现位置。
1，结果。角标。int
2，参数，数组，元素，int[] int
*/
public static int searchIndex(int[] arr,int key)
{
//1，遍历数组。
for (int x=0;x<arr.length ;x++ )
{
if(arr[x]==key)
return x;
}
return -1; //-1 不存在的角标
}
/*
幸运儿
1，循环，while
*/
/*
二分查找法。前提必须是被查找的数组是有序的。
*/
public static int getIndex(int[] arr,int key)
{
//1，定义三个变量，记录头角标、尾角标，中间角标。
int min,mid,max;
min = 0;
max = arr.length-1;
mid = (max+min)/2;//(max+min)>>1;
//2，因为不断折半，通过循环完成，只要没有找到就继续循环。
while(arr[mid]!=key)
{
//3，判断中间角标和key的大或者小。
if(key>arr[mid])
{
min = mid + 1;//小角标改变。
}
else if(key<arr[mid])
{
max = mid - 1;//大角标改变
}
//4,判断元素不存在的情况，只要小角标大于了大角标，就折半结束，并返回-1，标示 不存在的情况。
if(min>max)
return -1;
//因为max或者min的变化。重新计算mid值。
mid = (max + min) >> 1;
}
return mid;
}
//折半的另一中写法。
public static int getIndex2(int[] arr,int key)
{
int min,max,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;
else
return mid;
}
return -1;
}
//面试题：给定一个有序的数组，问，如果往数组中插入一个数据，
//还必须保证该数组有序，这个插入的位置如何找到？
public static int getIndex3(int[] arr,int key)
{
int min,max,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;
else
return mid;
}
return min; //
}
}
练习：
class Test
{
/*
需求：
定义一个功能，通过考试分数获取对应的等级。
如：
90-100A 或者优秀
80-89B 良好
70-79C 中等
60-69D 及格
60以下E 不及格
思路：
1，需要一个函数
2，结果有吗？有，char。
3，有参数吗？有，分数。
4，根据具体的分数判断在哪个范围内，才能确定等级。
步骤：
1，定义函数。
2，在函数中定义判断语句if。判断的是一个范围。
*/
public static String getLevel(int num)
{
/*
if(num>=90 && num<=100)
return "A";
else if(num>=80 && num<=89)
return "B";
else if(num>=70 && num<=79)
return "C";
else if(num>=60 && num<=69)
return "D";
else
return "E";
*/
String str;
if(num>=90 && num<=100){
str = "A";
}
else if(num>=80 && num<=89)
str = "B";
else if(num>=70 && num<=79)
str = "C";
else if(num>=60 && num<=69)
str = "D";
else
str = "E";
return str;
}
/*
需求：
编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，
例如，根据内容为{1,2,3}的数组形成内容为"1,2,3"的字符串。
思路：
1，遍历数组。
2，用","将数组元素连接上。
函数定义：
1，结果呢？字符串。
2，未知内容？数组。
*/
public static String arrayToString(int[] arr)
{
String temp = "";
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
temp = temp+arr[x]+",";
else
temp = temp+arr[x];
}
return temp;
}
/*
对一个数组中的元素进行反转
如
{34,16,23,99,50}-->
{50,99,23,16,34}
思路：
1，找到规律了，其实就是将头尾元素的位置进行置换。
2，在从头和尾进行递增和递减的操作。依次位置置换。
3，当头大于等于尾时，置换结束。
*/
public static void reverse(int[] arr)
{
for(int start=0,end=arr.length-1; start<end ; start++,end--)
{
swap(arr,start,end);
}
}
/*
定义一个对数组中两个元素进行位置的置换。
明确1：有结果吗？没有。
明确2：有参数吗？有，三个。数组，int ，int
*/
public static void swap(int[] arr,int index1,int index2)
{
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
public static void main(String[] args)
{
// int[] arr = {23,56,111,34,12};
// reverse(arr);
// swap(arr,2,4);
// String str = arrayToString(arr);
// System.out.println(str);
}
}
~~~~~~~~~~~
class ArrayDemo6
{
public static void main(String[] args)
{
//String week = getWeek(30);
//System.out.println("week="+week);
//System.out.println(Integer.toBinaryString(-6));//获取整数的二进制
//System.out.println(Integer.toHexString(26));//或者整数的十六进制。
}
/*
数组或者容器什么时候用？
当数据多的时候，先将这些数据都存储起来，在进行使用。
查表法。
其实就是在使用容器。
当对需求进行分析时，发现需求中存在着映射(对应)关系时。就可以使用容器。
数组：映射关系的一方是有序的数字(角标)。同时数据的个数必须是固定的。
*/
//需求：通过用户的输入的数字获取对应的星期
public static String getWeek(int num)
{
if(num<=0 || num>=8)
return num+"没有对应的星期";
//1，创建一个表。
String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
return weeks[num];
}
}
数组中的数组
二维数组
格式1：int[][] arr = new int[3][2];
1> 定义了名称为arr的二维数组
2> 二维数组中有3个一维数组
3> 每一个一维数组中有2个元素
4> 一维数组的名称分别为arr[0], arr[1], arr[2]
5> 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式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：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
1> 定义一个名称为arr的二维数组
2> 二维数组中的有三个一维数组
3> 每一个一维数组中具体元素也都已初始化
4> 第一个一维数组 arr[0] = {3,8,2};
5> 第二个一维数组 arr[1] = {2,7};
6> 第三个一维数组 arr[2] = {9,0,1,6};
7> 第三个一维数组的长度表示方式：arr[2].length;
class Array2Demo
{
public static void main(String[] args)
{
//二维数组定义。
int[][] arr = new int[3][2];//二维数组中有3个一维数组，每一个一维数组中有2个元素。
System.out.println(arr[0]);//[I@e6f7d2 数据类型@哈希值。
System.out.println(arr);// [[I@19836ed 数据类型@哈希值。
//int[] x = new int[3];
//System.out.println(x);
int[][] arr2 = new int[3][];
//分别对二维数组中的每一个小数组进行初始化。
arr2[0] = new int[3];
arr2[1] = new int[1];
arr2[2] = new int[2];
System.out.println(arr2[0]);//
}
}
class Array2Demo2
{
public static void main(String[] args)
{
int[][] arr = {{2,31,4,99},{78,35,9,6},{7,3,5,32}};
System.out.println(arr.length);//3
System.out.println(arr[1].length);//4
//求和。
int sum = 0;
for(int x=0; x<arr.length; x++)
{
for (int y=0;y<arr[x].length;y++ )
{
sum+=arr[x][y];
}
}
System.out.println("Hello World!");
}
}
class BreakDemo
{
public static void main(String[] args)
{
//break:作用于switch语句和循环语句。
for(int x=0; x<3; x++)
{
if(x==1)
break;//跳出循环，循环结束了。
System.out.println("x===="+x);
}
wai:for(int x=0; x<4; x++)
{
nei:for(int y=0; y<6; y++)
{
System.out.println("x="+x);
//break;//结束的是当前循环。
break wai;
}
}
}
}
class ContinueDemo
{
public static void main(String[] args)
{
//countinue:只能使用在循环语句中。继续循环。
//结束本次循环，继续下次循环。
for(int x=0; x<8; x++)
{
if(x%2==0)
continue;
System.out.println("x="+x); //1 3 5 7
}
wai:for(int x=0; x<4; x++)
{
nei:for(int y=0; y<6; y++)
{
System.out.println("x="+x);
continue wai;
}
}
}
}
转载于:https://blog.51cto.com/dodowolf/1422449
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
