java中实体数组赋值,java学习-数组

数组的定义

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

//      {

//            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

{

//3,进行判断比较。

if(arr[x]>max)

max = arr[x];

}

return max;

}

//第二种最大值。

public static int getMax2(int[] arr)

{

int maxIndex = 0;//初始化为数组中任意一个角标。

for (int x=0; 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

{

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

{

for(int y=x+1; y

{

//判断前一个大于后一个，就进行位置置换。

if(arr[x]>arr[y])

{

swap(arr,x,y);

}

}

}

}

/*

冒泡排序。

*/

public static void bubbleSort(int[] arr)

{

for(int x=0; x

{

for(int y=0; 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

{

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

{

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

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

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

{

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

{

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

{

for (int y=0;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;

}

}

}

}