42.【Java 基础之数组】

(一)、 continue

1.定义:

continue的用法就是:跳过此次循环进行下次循环.

2.图解:

小狮子想吃苹果，可是再第三个的时候有个小虫子。吃了虫子会拉肚子，可是小狮子特别想吃后面的苹果，咋整呢？对就是跳过有虫子的苹果，去吃其他的。这里的跳过苹果，继续吃其他的苹果的用法就是 continue/

代码展示:

package one;
import java.util.Scanner;
public class on {
public static void main(String []avgs) {
		for(int i=0;i<3;i++)
		{
				if(i==2) {
					continue;
				}
			System.out.println(i);	
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

效果展示:

(二)、break;

1.定义:

直接跳过整个大循环，不进行操作.

2.图解:

这时候来了个小狮子，小狮子饭量小，只需要吃两个苹果就饱了。后面的苹果就不吃了，那这里改用什么办法解决呢？对，大跳！！！ break,直接跳出这个循环结构，后面的苹果就不吃了.

代码展示:

package one;
import java.util.Scanner;
public class on {
public static void main(String []avgs) {
		System.out.println("请您输入被除数和除数分别为:");
		Scanner  sc=new Scanner(System.in);
		int bnumber,number,count=0;
		bnumber=sc.nextInt();
		number=sc.nextInt();
		while(bnumber>=number)
		{
			bnumber-=number;
			count++;
			break;
		}
		System.out.println("次数为:"+count);
		System.out.print("余数为:"+bnumber);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（三）、数组的定义和输出

1.数组的定义:

数组（Array）是有序的元素序列。[1]若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。[1]这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。

2.数组的初始化(静态)：

（1）.      数据类型  []  数组名=  new int[]{};
1

(2).      数据类型  []数组名 ={};
1

（3）.      数据类型   数组名[]=  new int[]{};
1

（4）.      数据类型 数组名[]=  {};
1

3.数组的访问:

索引的定义: 索引就是从0开始，数数的数字。也称下标:

3.1 单个索引访问:

代码展示：

package test;  //  包名

public class test1 {     //项目名
	public static void main(String []avgs)
	{
		//静态初始化:  int arry_age=new int[]{17,18,19};等效的
		System.out.println("请您输入年龄:");
		int arry_age[]= {15,16,17};
		arry_age[0]=100;
		int arry_age1[]=new int[]{17,18,19};
		System.out.println("请您输入姓名:");
		String []arry_name= {"黎明","王二"};		
		System.out.println("年龄为:"+arry_age[0]);  
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

效果展示：

3.2多个索引一起访问(遍历)

代码展示:

package test;  //  包名

public class test1 {     //项目名
	public static void main(String []avgs)
	{
		//静态初始化:  int arry_age=new int[]{17,18,19};等效的
		System.out.println("请您输入年龄:");
		int arry_age[]= {15,16,17};
		arry_age[0]=100;
		int arry_age1[]=new int[]{17,18,19};
		System.out.println("请您输入姓名:");
		String []arry_name= {"黎明","王二"};
		for(int i=0;i<3;i++)
		{
			System.out.println("年龄为:"+arry_age[i]);
		}
	   for(int i=0;i<2;i++)
	   {
		System.out.println("姓名为:"+arry_name[i]);		
	   }	   
	}
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 3 (length函数求数组的长度)

代码展示:

package test;  //  包名

public class test1 {     //项目名
	public static void main(String []avgs)
	{
		//静态初始化:  int arry_age=new int[]{17,18,19};等效的
		System.out.println("请您输入年龄:");
		int arry_age[]= {15,16,17};
		arry_age[0]=100;
		int arry_age1[]=new int[]{17,18,19};
		System.out.println("请您输入姓名:");
		String []arry_name= {"黎明","王二"};
		for(int i=0;i<arry_age.length;i++)
		{
			System.out.println("年龄为:"+arry_age[i]);
		}
	   for(int i=0;i<arry_name.length;i++)
	   {
		System.out.println("姓名为:"+arry_name[i]);	
	   }
	}
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

效果展示:

(四).动态数组的初始化:

1.动态数组的定义:

定义:就是我们可以动态的键盘手动输入:

2.动态数组初始化的格式:

（1）.			数据类型 arry_age[]=new 数据类型[50];
1

（2）.			数据类型 []arry_age=new 数据类型[50];
1

3.动态数组的键盘录入

代码展示:

package test;  //  包名
import java.util.Scanner;
public class test1 {     //项目名
public static void main(String []avgs)
	{
		//静态初始化:  int arry_age[]=new int[]{17,18,19};等效的
		System.out.println("请您输入年龄:");
		Scanner sc=new Scanner(System.in);
		int arry_age[]=new int[3];
		for(int i=0;i<arry_age.length;i++)
		{
		    arry_age[i]=sc.nextInt();
		}
		for(int i=0;i<arry_age.length;i++)
		{
			System.out.println("年龄为:"+arry_age[i]);
		}	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

效果展示:

（五）、动态数组的之间的赋值

必知小知识: 数组名不仅代表数组的首地址，&a的话就代表一个指针。指针类型是a的类型加一个*,指向的是a的类型。而且还代表着这个数组.数据类型是 数据类型[]

反列: 我的目的是把动态数组赋值给动态数组

动态数组之间的赋值操作:

import java.util.Scanner;
public class tese {
    public static void main(String[] avgs) {
        int[] number_arr = new int[5];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < number_arr.length; i++) {
            number_arr[i] = sc.nextInt();
        }
//        for (int i = 0; i < number_arr.length; i++) {
//            System.out.println(number_arr[i]);
//        }
        int []arr=number_arr;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

(六)、经典用法:

1.猜数字游戏

需要的第一个包: 随机数包

import java.util.Random;    //导入包

Randon r=new Random();      //声明包

int number=r.nextInt(100)  //范围是 0~99  使用包
1
2
3
4
5

代码展示:

import java.util.Scanner;   //导输入包
import java.util.Random;    //导随机数包
public class one
{
	public static void main(String []avgs)
	{
		Scanner sc=new Scanner(System.in);
		Random r=new Random();     //
		int Number;
		Number=r.nextInt(100)+101;   //  100-200
		System.out.println("系统给定的随机数是:");
		System.out.println(Number);
		int i,j=0;
		while(true)
		{
			System.out.println("请您再输入一个数字\n");
			i=sc.nextInt();
			j++;
			if(i>Number)
			{
				System.out.println("您猜的数字大了\n");
			}
			else if(i<Number)
			{
				System.out.println("你猜的数字小了\n");
			}
			else
				break;
		}
		System.out.println("您一共用了"+(j)+"次机会赢得了游戏");

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

效果展示:

2.回文数:

基本思路:回文数有一个特点，那么就是首尾堆成，比如说12321 是一个回文数，1232 这不是一个回文数.根据这个特点，我们可以知道把个位、十位…反过来也是等于原来的数字的，所以我们可以知道基本操作 :
gw =x%10; x=x/10,然后用sum进行颠覆运算.

代码展示:

import java.util.Scanner;   //导输入包
public class one
{
	public static void main(String []avgs)
	{
		System.out .println("请您输入一个三位数以上的数字:\n");
		Scanner sc=new Scanner(System.in );
		int number=sc.nextInt();
		int sum=0,temp=number;
		while(number!=0)
		{
			int gw=number%10;
			number=number/10;
			sum=sum*10+gw;
		}
		System.out.println(temp);
		System.out.println(sum);
			System.out.println(temp==sum);
			//System.out.println("不是一个回文数\n"+sum);		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.求被除数和除数的商和余数

题目描述:假如我们给您两个数据一个被除数一个是除数。要求我们不能用 / % 求取这两个数的商和余数;
基本思路:首先我们要知道一个知识，那就是:被除数1-除数=被除数2 … 被除数2-除数=被除数3…被除数n-除数=余数 ，然后他们计算的次数就是我们要的商

代码展示:

package one;
import java.util.Scanner;
public class on {
public static void main(String []avgs) {
		System.out.println("请您输入被除数和除数分别为:");
		Scanner  sc=new Scanner(System.in);
		int bnumber,number,count=0;
		bnumber=sc.nextInt();
		number=sc.nextInt();
		while(bnumber>=number)     //假如说被除数大于除数就进入循环体，否则推出
		{
			bnumber-=number; 
			count++;         //计算商的
		}
		System.out.println("商为:"+count);
		System.out.print("余数为:"+bnumber);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

效果展示:

4.数组求最大值:

题目描述:
我们已经知道了一个数组 的数，然后求最大值:

代码展示:

package test;  //  包名
import java.util.Scanner;
public class test1 {     //项目名
	public static void main(String []avgs)
	{
		int arr[]=new  int[] {22,35,87,26,20};
		int max;
		max=arr[0];
		for(int i=0;i<arr.length;i++)
		{
			if(arr[i]>max)
			{
				 max=arr[i];
			}
		}
		System.out.print("最大值为:"+max);
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

效果展示:

5.数组中的数据交换

题目描述:已知数组arr的数字，让他们进行首尾交换，比如说 12345 ，交换后为:54321.
刨析: 定义两个整形变量，i,j ; 循环条件是 i

for(int i=0,j=arr.length-1;i<arr.length/2;i++,j--)
1

代码展示:

package test;  //  包名
public class test1 {     //项目名
	public static void main(String []avgs)
	{
		int arr[]=new  int[] {22,35,87,26,20};
		for(int i=0,j=arr.length-1;i<arr.length/2;i++,j--)
		{
			int temp;
			temp=arr[i];
			arr[i]=arr[j];
			arr[j]=temp;
		}
		System.out.println("交换后的数据为:");
		for(int i=0;i<arr.length;i++)
		{
			System.out.println(arr[i]);
		}
			}		
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

效果展示:

7.数组堆内存和栈内存:

1)、栈内存的概念:
栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量等，其操作方式类似于数据结构中的栈。
eg:

package test
public class one{
public static void main(String []avgs)
{
int a;  //栈
int b=3;   //栈
char*p;  //栈
}
}
1
2
3
4
5
6
7
8
9

其中函数中定义的局部变量按照先后定义的顺序依次压入栈中，也就是说相邻变量的地址之间不会存在其它变量。栈的内存地址生长方向与堆相反，由高到底，所以后定义的变量地址低于先定义的变量，比如上面代码中变量 s 的地址小于变量 b 的地址，p2 地址小于 s 的地址。栈中存储的数据的生命周期随着函数的执行完成而结束。（先进先出）
2)、图解

3）、堆内存
堆内存的定义:如果有关键字 new 加持的，那么就放在堆区，比如果 数组

复习一下三种结构请点我