数组java练习总结
学习目标：
- 数组基础知识
学习内容：
1.
从键盘读入学生成绩，找出最高分， 并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组， 存放学生成绩。
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生人数：");
int p = sc.nextInt();
//学生人数
System.out.println("请输入"+p+"个成绩");
int[] score = new int[p];
//根据人数输入成绩后，创建int数组
for(int i=0;imax){
max=score[i];
}
}
System.out.println("最高分是："+max);
//遍历找到最高分
char level;
for(int i=0;i= max-10){
level='A';
}else if(score[i] >= max-20){
level='B';
}else if(score[i] >= max-30){
level='C';
}else{
level='D';
}
System.out.println(i+"号学生的成绩是"+score[i]+"等级为"+level);
}
}
}
思路：
1）键盘输入学生的成绩，这里可以先输入学生的人数，再去输入成绩，先根据输入的人数，创建一个成绩的数组，将输入的成绩赋值到数组中。
2）存在成绩数组，for循环遍历找到成绩最高分，打印输出最高分。
3）再用一个for循环遍历数组，if语句进行成绩和最高分的差值比较，不同分段给出等级，最后打印输出成绩和相应的等级。
2.
升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。 屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。以下是联系信息！
• public class ArrayTest {
• public static void main(String[] args) {
• int[] arr = new int[]{8,2,1,0,3};
• int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
• String tel = “”;
• for(int i = 0;i < index.length;i++){
• tel += arr[index[i]];
• }
• System.out.println(“联系方式：” + tel);
• }
• }
解析： tel += arr[index[i]]; 从这句代码中找到联系电话，按照优先级，先得到index[i]为多少，再去找arr[ ]是多少，最终得到电话号码。
18013820100
3.
创建一个长度为6的int型一维数组，要求取值为1-30，同时要求元素值各不相同（提示可以使用Random来随机给数组赋值）
/*面试题目：
创建一个长度为6的int型一维数组，
要求取值为1-30，同时要求元素值各不相同 */
import java.util.Scanner;
import java.util.Random;
public class HelloWorld {
public static void main(String[] args) {
int[] arr = new int[6]; //长度为6的int型数组
Random r = new Random(); //创建对象
for(int i=0; i思路：
1）遍历给数组的每一个元素赋值，为保证每个元素各不相同，需要再嵌套一个循环，进行判断，如果元素相等，索引数减一，退出当前循环，在外层循环重新赋值一个随机数，直到数组中每个元素赋值完毕，并且各不相同。
4.
/*创建一个char类型的36个元素的数组，
前26个元素放置’A’-‘Z’, 后10个元素放置’0’-‘9’。
使用for循环访问所有元素并打印出来。
提示：char类型数据运算 ‘A’+1 -> ‘B’，‘0’+1 -> ‘1’ */
public class HelloWorld {
public static void main(String[] args) {
char[] a = new char[36];//创建数组
char letter='A';
for(int i=0;i思路：
1）首先创建数组，定义一个字符类型变量，让它从A开始
2）利用for循环，循环36次，注意数组的索引从0开始，其中的letter也要随着循环次数增加
3）增加判断条件，前26个位大写字母，后10个元素是0-9，所以再i为25时，利用题目给出的‘0’+1 -> ‘1’，char类型运算，将letter值改变，修改为’0’-1，然后letter随循环加一，a[25]=0
4）在判断结束时，打印输出每一个数组元素，System.out.print(a[i]);
5.
/*输入数组{4，6，7，8，1，2，5}，
最大的与第一个元素交换，最小的与最后一个元素交换，输出数组 */
public class HelloWorld {
public static void main(String[] args) {
int[] a={4,6,7,8,1,2,5};
int max=0,maxIndex=0,min=0,minIndex=0;//定义最大最小值和其索引
for(int i=0;imax){//找到最大值
max=a[i];
maxIndex=i;//保存找到的最大值的索引
}
}
a[maxIndex]=a[0];//交换最小元素的位置
a[0]=max;
for(int i=1;i 思路：
1）建立相应的数组，交换位置，要注意地址，可以利用Index来进行索引的存放。
2）利用for循环找到数组的最大最小值，修改max，min，注意保存找到的这个元素的索引。
3）找到之后要进行位置的交换，因为是数组，所以是用a[maxIndex]/a[minIndex]来和找到的a[i]交换位置，并把最大最小元素赋值给交换后的数组元素。
4）最后遍历输出
6.
/*将一个给定的整型数组转置输出，
例如： 源数组，1 2 3 4 5 6
转置之后的数组，6 5 4 3 2 1 */
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
int[] a = {1,2,3,4,5,6};
int t;
for(int i=0;ia[i]){
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
}
for(int i=0;i 思路：
1）首先给定一个整型数组，利用for循环，进行length-1次的比大小调整位置。
2）再嵌套一个for循环，找到要跟a[i]比大小的数a[j]，用if语句比大小，之后交换位置。
3）for循环遍历打印输出转置之后的数组。
7.
/*现在有如下的一个数组：
int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
int[] newArr = {1,3,4,5,6,6,5,4,7,6,7,5} ; */
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
int i;
int count=0;
for(i=0;i思路：
1）核心思路，根据题目要求，要将旧数组中的0删掉，然后打印输出一个新的数组，所以需要统计0的项数，再去new新的数组空间。
2）遍历数组，用if语句判断是否为0，为0则加一。
3)new新的数组，长度用旧数组长度减去0的项数。
4)for循环和if语句，如果这个数组元素不为0，那么就将它赋值给新的数组元素，此时需要一个新的变量来确定新数组的索引，执行完这个操作，需要自加一。
5）遍历输出打印新的数组。
8.
/*现在给出两个数组：
数组a："1,7,9,11,13,15,17,19"
数组b："2,4,6,8,10"
两个数组合并为数组c。
*/
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
int[] a ={1,7,9,11,13,15,17,19};
int[] b ={2,4,6,8,10};
int[] c = new int[13];
int i;
for(i=0;i=0;i--){//冒泡排序，i的逐级递减
for(int j=0;jc[j]){
int t = c[j+1];
c[j+1]=c[j];//交换位置
c[j]= t;//交换数值
}
}
}
System.out.println(Arrays.toString(c));
}
}
思路：
1）手动统计数组的索引，两次for循环，将a、b数组衔接起来。
2）进行冒泡排序，i的逐级递减，如果后面的元素大于前面的元素就交换它们。
3）输出整个数组，用了Arrays，强制输出
下面是更简洁的方法
System.arraycopy一共有5个参数：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
- Object src：原数组
- int srcPos：从原数组的哪里（数组的地址,比如从第一数拷贝就写0,）开始拷贝
- Object dest：目标数组（被拷贝到哪）
- int destPos：从目标数组的哪里（同样填写数组元素中的地址）开始插入
- int length： 复制原数组中元素的个数，比如复制3个元素就写3
比如：
System.arraycopy(a, 0, c, 0, a.length)：
是从a数组的第一数开始复制，复制到c数组中第一个数的位置，复制的元素个数为a数组的全部元素 （ a.length）
原文链接：https://blog.csdn.net/weixin_41610825/article/details/89364226
//System.arraycopy(源数组，源数组起始位置，目的数组，目的数组起始位置，复制长度);
//对于二维或者一维数组中存放的是对象时，复制结果是一维的引用变量传递给副本的一维数组，修改副本时，会影响原来的数组。
public static void main(String[] args) {
int[] a= {1,7,9,11,13,15,17,19};
int[] b= {2,4,6,8,10};
int[] c= new int[a.length+b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
Arrays.sort(c);//给数组c进行升序拍序，Arrays.sort()是Arrays类的静态方法，可以直接拿来使用
System.out.println(Arrays.toString(c));
}
}
9.
/*现B哥去参加青年歌手大奖赛,有10个评委打分,
(去掉一个最高一个最低)求平均分是多少?
评委打分：99,97,96,95,94,92,91,90,88,100
*/
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
int[] s = {99,97,96,95,94,92,91,90,88,100};
int i;
int max=0,min=s[0];
float ave=0;
for(i=0;imax){
max=s[i];
}
if(s[i] 思路：
1）遍历找到数组的max，min值，注意min的初始值设为数组的第一个元素。
2）for循环，去掉最高分、最低分的分数，用 ave += s[i];得到总分，最后除以8，输出平均分。
10.
/*给定一个整型数组，
数组成员10个,求该数组中第二大的数的下标
数据如图：{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};--0，1，2，3，4，5，6，7，8，9
*/
import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int max=0,maxIndex=0,second=0,secondIndex=0;
for(int i=0;imax){
second=max;
secondIndex=maxIndex;
max=a[i];
maxIndex=i;
}else{
if(a[i]>second){
second=a[i];
secondIndex=i;
}
}
}
System.out.println("该数组第二大数为："+second+"，下标是"+secondIndex);
}
}
思路：
1）第二大的数怎样可以得到呢，只要作为数组中小于最大数，大于其他数。
2）for循环遍历，先找到最大数，找到下一个最大值，就把上一个最大数的值和位置赋值给第二大数，如果遍历的这个数不大于最大数，就去和第二大数进行比较，符合条件就将这个数赋值给第二大数。
11.
JAVA程序的main方法必须写在类里面
为一个boolean类型变量赋值时， boolean a = (9 >= 10);
for循环体语句中，可以包含多条语句，但要用大括号括起来
[基本数据类型和String相加结果一定是字符串型
在我们把一个基本数据类型和一个String类型相加的时候，编译器会将基本类型的值传入到对应封装类的toSting()方法中将其转化为和值相同的String对象，从而和String进行相加运算。基本类型本身并不能直接与String类型相加。]
12.
定义一个长度为10的整型数组，循环输入10个整数java。 然后将输入一个整数，查找此整数，找到 输出下标，没找到给出提示。
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
int[] a = new int[10];
//键盘输入数组，并给数组赋值
Scanner sc = new Scanner(System.in);
System.out.println("请输入10个整数：");
for(int i=0;i思路：
1）首先定义输入10个整数，for循环将输入的每个整数赋值给数组。
2）输入数组后，再输入一个要查找的数，这里运用到boolean立旗操作，通过遍历直到找到这个数为止，跳出循环，如果找到，将boolean fl 赋值为true。
3）找到这个数给出下标，没有这个数，给出提示，用if和fl进行两种情况的输出。
13.二维数组
求一个3*3矩阵对角线元素之和，要求矩形里面的值为随机赋值
*/
import java.util.Random;
public class HelloWorld {
public static void main(String[] args) {
int[][] a = new int[3][3];
int sum=0;
Random r = new Random();//创建随机数对象
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
a[i][j]=r.nextInt(100);//随机数赋值到3*3矩阵中
if(i==j){//情况一，行号和列号一致
sum += a[i][j];
}//情况二，坐标为(2,0)(0,2)
if((i==2 && j==0)||(i==0 && j==2)){
sum += a[i][j];
}
}
}
System.out.println("对角线之和："+sum);//打印输出
}
}
思路：
1）首先 3乘3 矩阵涉及到二维数组，a[i][j]表示一个位置的，前面是行号，后面是列号。
2）将随机数赋值到矩阵中，3*3矩阵说明for循环有两个并且嵌套在一起。
3）遍历矩阵，if语句进行判断，对角线规律，行号和列号有两种情况，行号、列号一致和顶点处的元素，将对角线之和加在一起，打印输出。
补充：
二维数组
二维数组的定义：类型 数组名[行号][列号]
eg：int arr[3][4]
14.
/*
自定义一个字符串数组，提示用户输入5个字符串，
通过循环语句实现将用户输入的字符串存放到数组里，
然后反向输出这五个字符串。
*/
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
String[] s = new String[5];
Scanner sc = new Scanner(System.in);
System.out.println("请输入5个字符串：");
//定义字符串数组，创建输入对象
for(int i=0;i思路： 思路： 思路：
虽然是String数组，但是基本思路和int数组一致，交换位置，交换次数;i15.
/*
打印扑克牌.
提示：可定义如下的数组
String[] hs = {"♠","♥","♣","♦"};
String[] ds = {"A","2","3","4", "5","6","7","8","9","10","J","Q","K"};}
代码实现，效果如图所示：
♠A ♠2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K
♥A ♥2 ♥3 ♥4 ♥5 ♥6 ♥7 ♥8 ♥9 ♥10 ♥J ♥Q ♥K
♣A ♣2 ♣3 ♣4 ♣5 ♣6 ♣7 ♣8 ♣9 ♣10 ♣J ♣Q ♣K
♦A ♦2 ♦3 ♦4 ♦5 ♦6 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♦K
*/
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
String[] hs = {"♠","♥","♣","♦"};
String[] ds = {"A","2","3","4", "5","6","7","8","9","10","J","Q","K"};
for(int i=0;i
1）观察效果图，是由4行图案，13列的数组成，由此我们可以想象成一个4*13的矩阵，利用两层for循环来实现。
2）每次打印输出hs[i]+ds[j]，没打印完一个花色就进行转行，所以内层循环外，打印输出转行。16.
/*
判断数组中的元素值是否对称.
效果展示：java
{1,2,3,4,3,2,1}是否对称：true
{1,2,3,4,5,6,7}是否对称：false
*/
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7};
boolean flag = true;
for(int left=0,right=a.length-1;left<=right;left++,right--){
if(a[left] != a[right]){
flag=false;
break;
}
}
System.out.println("是否对称？"+(flag ? true : false));
}
}
1）元素是否对称，要看数组的首尾每组数是否相等，为了在循环中，左右两端进行比较，这里声明了left和right两个变量，它们是数组的索引。
2）left每次加一，right每次减一，随循环逐渐靠近中部，直到它们相等停止，如果索引指向的两个元素不相等，那么就用boolean类型变量flag，flag就返回false，break退出循环。
3）用三元运算符，进行boolean flag的结果输出。