java input 数组_Java基础之:数组
Java基础之:数组
一组相同数据类型的数据,我们即称之为 数组,数组也是一种数据类型。
需要注意的是 , 数组和String 字符串 相同,也是引用类型的。
数组的初始化
方式一:动态初始化
四种格式:
int[] arr = new int[5];
int arr[] = new int[5];
int arr[]; arr = new int[5];
int[] arr; arr = new int[5];
我们可以通过 : 数组名.length (返回值为int类型) 的方式获得数组的长度,需要注意的是,数组的下标是从0开始的。
//生成一个int类型数组,放入5个数 {1,2,3,4,5}
int[] arr = new int[5];
for(int i = 0;i < arr.length;i++){
arr[i] = i + 1;
}
注意:若声明了数组,却没有赋值,则需要注意每个数据类型创建的数组默认值是什么。
int/short/byte/long默认值为0,String默认值为null,float/double默认值为0.0,char默认值为 \u0000,boolean默认值为false.
方式二:静态初始化
两种格式:
int[] arr = {1,2,3};
int[] arr = new int[]{1,2,3};
数组的赋值
arr[0] = 1; 这就是最基本的数组赋值方式,通常我们使用循环的方式来给数组赋值。
但需要注意的是,数组是引用类型。
说明:
这里声明了两个数组,第二个数组并没有生成一个新的堆空间,而是在栈中生成了一个空间指向arr1在堆中的空间。
arr1 与 arr2共用一个堆空间,导致了若改变arr2中的值也会影响到arr1。
若要改变这一点应该让arr2重新生成一个空间,再将arr1中的内容复制到arr2中,代码如下:
int[] arr1 = {1,2,3};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < arr2.length;i++){
arr2[i] = arr1[i];
}
数组灵活运用
数组逆序输出
import java.util.Scanner;
//数组元素反转
public class ArrayApply
{
public static void main(String[] args) {
//要求:随机生成五个数,并将其反转打印,把数组的元素内容反转.
//arr{1,2,3,4,5} {5,4,3,2,1}
/*
思路分析
1. 第一个元素和最后元素交换, 第二个元素和倒数第二个元素交换 , 以此类推
2. 交换次数 arr.length / 2
也可以使用一个中间数组 temp 先将arr放入temp中,再将temp逆序复制给arr
*/
int[] arr = {1, 2, 3, 4, 5, 10};
int temp = 0;
for( int i = 0 ; i < arr.length / 2; i++) { // i 次数, 同时下标
// i = 0 i = 4 (arr.length-1-0)
// i = 1 i = 3 (arr.length-1- 1)
temp = arr[i];
arr[i] = arr[arr.length-1 - i];
arr[arr.length-1 - i] = temp;
}
System.out.println("==============");
for( int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
在数组指定位置插入数据
//将一个数插入数组中的指定位置。 化繁为简的思路!!!
//1.首先考虑如何将一个数放入数组的最后,即数组扩容
//2.其次考虑如何实现数组的动态增减
//3.最后思考将数据放入数组中的指定位置
import java.util.Scanner;//一定要注意这里需要一个分号!!
public class ArrayApply1
{
public static void main(String[] args){
//动态输入数组
Scanner input = new Scanner(System.in);
int max = 0;
int maxIndex = 0;
System.out.println("输入数组长度:");
int arrLength = input.nextInt();
int[] arr = new int[arrLength];
System.out.println("输入数组内容:");
for(int i = 0 ; i < arr.length ; i++){
arr[i] = input.nextInt();
}
//1.实现将一个数放入数组的最后,即数组扩容
//思路: 1.使用一个临时数组,temp,temp.length = arr.length+1
// 2.再将arr数组中的数据遍历赋值到temp中
// 3.最后将arr指向temp数组
//String flag = null;//初始化String,JVM默认分配的值也是null,所以这里可以不写null
//do{
//System.out.println("是否要添加数据(Y/N)");
//flag = input.next();
//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较
//int[] temp = new int[arr.length + 1];
//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp
//temp[i] = arr[i];
//}
//System.out.println("输入要添加的数据:");
//int tempInt = input.nextInt();
//temp[temp.length-1] = tempInt;//将数据放在temp最后
//arr = temp;//栈空间中的arr指向temp数组在堆中的空间
//}
//System.out.println("插入数据后的数组为:");
//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组
//System.out.print(arr[i]+ "\t");
//}
//System.out.println();
//}while(!"N".equalsIgnoreCase(flag));
//========================================================================================
//2.实现数组的动态增减(默认减掉数组最后一个数据)
//String flag = null;//初始化String,JVM默认分配的值也是null,所以这里可以不写null
//String flag2 ;
//do{
//System.out.println("是否要改变数据(Y/N)");
//flag = input.next();
//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较
//System.out.println("增加数据或减少数据(IN/OUT)");
//flag2 = input.next();
//if("IN".equalsIgnoreCase(flag2)){
//int[] temp = new int[arr.length + 1];
//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp
//temp[i] = arr[i];
//}
//System.out.println("输入要添加的数据:");
//int tempInt = input.nextInt();
//temp[temp.length-1] = tempInt;//将数据放在temp最后
//arr = temp;//栈空间中的arr指向temp数组在堆中的空间
//}else if("OUT".equalsIgnoreCase(flag2)){//减掉数组的最后一位
//int[] temp = new int[arr.length - 1];
//for(int i = 0 ; i < temp.length ; i++){//先将arr赋值给temp
//temp[i] = arr[i];
//}
//arr = temp;//栈空间中的arr指向temp数组在堆中的空间
//}else{
//System.out.println("输入错误!");
//}
//}
//System.out.println("改变数据后的数组为:");
//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组
//System.out.print(arr[i]+ "\t");
//}
//System.out.println();
//}while(!"N".equalsIgnoreCase(flag));
//========================================================================================
//3.数据放入数组中的指定位置自己的思路
//String flag ;
//int inIndex;
//do{
//System.out.println("是否要添加数据(Y/N)");
//flag = input.next();
//if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较
//System.out.println("输入要添加数据的位置(下标):");
//inIndex = input.nextInt();
//int[] temp = new int[arr.length + 1];
//for(int i = 0 ; i < arr.length ; i++){//先将arr赋值给temp,i表示arr数组的下标
//if(i == inIndex){
//temp[i] = 0;//将要插入的位置空出
//temp[i+1] = arr[i];//由于将temp这个位置空出来了,所以arr[i]赋值给下一个位置
//}else if(i < inIndex){
//temp[i] = arr[i];//将要插入位置前面的数据放入
//}else{
//temp[i+1] = arr[i];
将要插入位置后面的数据放入,由于空出了一个位置所以这里需要i+1
//}
//}
//System.out.println("输入要添加的数据:");
//int tempInt = input.nextInt();
//temp[inIndex] = tempInt;
//arr = temp;//栈空间中的arr指向temp数组在堆中的空间
//}
//System.out.println("插入数据后的数组为:");
//for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组
//System.out.print(arr[i]+ "\t");
//}
//System.out.println();
//}while(!"N".equalsIgnoreCase(flag));
//3.数据放入数组中的指定位置韩顺平老师的思路
String flag ;
int inIndex;
do{
System.out.println("是否要添加数据(Y/N)");
flag = input.next();
if("Y".equalsIgnoreCase(flag)){//equalsIgnoreCase()代表不区分大小写的比较
System.out.println("输入要添加数据的位置(下标):");
inIndex = input.nextInt();
//加入一个判断下标是否正确的语句
if(!(inIndex >= 0 && inIndex <= arr.length)){
//满足条件执行,那么取反则不执行,这样易于代码的阅读
System.out.println("输入下标错误,应该在0-"+arr.length+"之间!");
continue;
}else{
int[] temp = new int[arr.length + 1];
//这里需要 i < temp.length , 因为 i 不再是表示arr的下标,而是temp的下标
for(int i = 0,j = 0 ; i < temp.length ; i++){//j表示arr的下标
if(i != inIndex){//到了插入的位置,直接跳过temp数组的这个位置
temp[i] = arr[j];
j++;
}
}
System.out.println("输入要添加的数据:");
int tempInt = input.nextInt();
temp[inIndex] = tempInt;
arr = temp;//栈空间中的arr指向temp数组在堆中的空间
}
}
System.out.println("插入数据后的数组为:");
for(int i = 0 ; i < arr.length ; i++){//插入完后打印一下数组
System.out.print(arr[i]+ "\t");
}
System.out.println();
}while(!"N".equalsIgnoreCase(flag));
}
}
java input 数组_Java基础之:数组相关推荐
- java 一维数组_java基础 ---- 一维数组
为什么要使用数组: 因为不使用数组计算多个变量的时候太繁琐,不利于数据的处理. -------- 数组也是一个变量,是存储一组相同类型的变量 声明一个变量就是在内存中划出一块合适的空间 声明一个数 ...
- java实现初始化三角形数组_Java基础之数组初始化和数组JVM分析
什么是数组 所谓数组,是具有相同数据类型的若干变量或者数据按照一定排序规则组合起来的一种数据存储格式.数组中的数据称为数组元素,我们使用索引来标识数组元素在数组中的存储位置,索引从0开始,步长是1,其 ...
- java web定义数组_Java基础之数组--数组常用操作
3.2一维数组 3.2.1声明数组 数组类型[] 数组名称:int[] username; 或者 数组类型 数组名称[];int username[]; 3.2.2初始化一维数组 一维数组初始化有两种 ...
- java mp3数组_Java基础之数组(一)
数组的定义 数组是相同类型数据的有序集合.数组描述的是相同类型的若干个数据,按照 一定的先后次序排列组合而成.其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们.数组的三个基本特 ...
- java基础题数组_java基础学习——数组笔试题
1.求2到1000的质数,且每输出十个进行换行? 2.使用两种方式,使数组的初始化为4. 3.查询书组中的最小值,并将书组扩容为新的数组. 答案: 1.代码块:package Test; public ...
- java返回特定下标元素_java基础--输出数组中指定元素的下标
java基础--输出数组中指定元素的下标 java基础--输出数组中指定元素的下标 package com.lcn.day05; public class ArrayDemo8 { /** * 输出数 ...
- java中两个doub组成一个数组_Java基础知识2-Java基本语法
数据类型 1.Java程序的基本组成 关键字:被Java语言赋予特定含义的单词,不能作标识符,如private. 标识符:由数字.字母.$和_组成的字符串,用于引用变量.且首字母不能是数字. 变量:程 ...
- java枚举类型数组_Java基础(七)泛型数组列表ArrayList与枚举类Enum
一.泛型数组列表ArrayList 1.在Java中,ArrayList类可以解决运行时动态更改数组的问题.ArrayList使用起来有点像数组,但是在添加或删除元素时,具有自动调节数组容量的功能,而 ...
- java数组键_Java基础之数组
数组 数组就是用于存储相同数据类型数据的一个容器.可以通过有规律的索引来访问没有规律的元素. 一维数组 定义格式:元素的数据类型[ ] 数组名称 = new 元素的数据类型 [ 数组容器大小 ]: 数 ...
最新文章
- oracle别名作用范围,在Oracle的Where子句子查询中使用别名或表名,
- 去掉softmax后Transformer会更好吗?复旦华为诺亚提出SOFT
- 【最全解析】1050 螺旋矩阵 (25分)
- 工业交换机与工业路由器的区别
- martingale、markov chain、Monte Carlo、MCMC
- 7种有害的IT团队行为,不根除就坏大事了
- 定位20万个星系只需10秒!这款AI神器带你撩开宇宙面纱
- 企业运维经典面试题汇总(2)
- Tensorflow源码编译
- 从小到大排列组合 php,求一个一维数组中,n个元素的不同组合,并返回该数组
- 关联规则挖掘之FPGrowth算法实现
- HTML5网页设计基础——拼图效果
- Wireshark流量分析
- PASCAL VOC 数据集详解与MS COCO组合方式
- 详解Minimax算法与α-β剪枝
- 两种随机数生成方法——反函数法和舍选法
- 《游戏设计艺术(第2版)》——学习笔记(8)第8章 游戏通过迭代提高
- DataX oracle同步mysql(全量和增量)
- CIF,D1,HALF D1,FULL D1
- 软件测试工程师澳洲移民,App Store 上的“澳洲公民入籍考试 (2021)”
热门文章
- MMD_2b_NearestNeighborLearning
- 机器学习在生物信息(如DNA比对等方面)的研究现状是怎样的?
- python3环境搭建(利用Anaconda+pycharm+pytorch)
- STM32-USART发送程序
- 通讯接口:I2C和USART,SPI,CAN,USB2.0
- tf.keras.losses.CategoricalHinge 损失函数示例
- 目标检测--RON: Reverse Connection with Objectness Prior Networks for Object Detection
- 图像理解--Detecting and Recognizing Human-Object Interactions
- ClickHouse 系列教程五:多种连接方法
- java 高并发解决方案