一、重要提醒
1、next()与nextLine()的区别:
(1)单独使用的时候效果一样;
(2)nextLine()可以接收一些特殊字符 如空格 tab等,而next()直接忽略接收。
import java.util.Scanner;
public class ScannerWenTiDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//next()
// String s1 = sc.next();
// System.out.println(s1);
//nextLine()
// String s2 = sc.nextLine();
// System.out.println(s2);
//在输入一个nextLine时候输入一个nextInt 此时是没问题的
// String s3 = sc.nextLine();
// int number = sc.nextInt();
// System.out.println(s3);
// System.out.println(number);
//先输入一个nextInt再输入一个nextLine
// int number2 = sc.nextInt();
// String s4 = sc.nextLine();
// System.out.println(number2);
// System.out.println(s4);
//先输入一个nextInt再输入一个next
// int number2 = sc.nextInt();
// String s4 = sc.next();
// System.out.println(number2);
// System.out.println(s4);
}
}
2、思考题
public class SiKaoTiDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //10,20
change(a,b);
System.out.println("a:"+a+",b:"+b); //a=?,b=?
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //arr[1] = 2? ??
}
public static void change(int a,int b) {
System.out.println("a:"+a+",b:"+b); //10,20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a=20,b=40
}
public static void change(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
}
}
3、输入四行五列“*”。
public class WenTiDemo1 {
public static void main(String[] args) {
for(int i=1;i<=4;i++){
for(int j=1;j<=5;j++){
System.out.print("*");
}
System.out.println();
}
}
}
二、一维数组
1、数组:
需求:现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。
假设该公司有80名员工,用前面所学的知识,程序首先需要声明80个变量来分别记住每位员工的工资,然后在进行操作,
这样做会显得很麻烦。为了解决这种问题,Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析:我们可以得到如下两句话:
(1)、数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
(2)、数组既可以存储基本数据类型,也可以存储引用数据类型。
语句定义格式:
格式1:数据类型[] 数组名;
举例:int[] arr; 推荐第一种方式。
格式2:数据类型 数组名[];
举例:int arr[] 定义一个存放int类型数据的数组。
为什么不推荐使用第二种方式。
从辨识度来看,第一种一眼就能识别是一个数组。
从使用长久来看,今后使用的趋势是第一种,第二种渐渐会被淘汰。
数组不初始化不能被使用,初始化?
初始化就是给这个变量开辟一个内存空间,为将来的值提供存放的空间
那么数组如何初始化呢?
两种:
(1)、动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
动态初始化的语句格式:
存放元素的数据类型[] 数组名 = new 存放元素的数据类型[数组的长度];
举例:定义一个可以存放3个int类型数据的数组。
int[] bigdata15 = new int[3];
(2)、静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
public class ArrayDemo1 {
public static void main(String[] args) {
//第一种格式定义
// int[] arr;
//第二种格式定义
// int arr1[];
//没有初始化能直接赋值
// System.out.println(arr);
//动态初始化一个数组:定义一个可以存放3个int类型数据的数组。
/**
* 左半部分:
* int: 表示数组中存放元素的数据类型是int类型
* []: 表示是一个一维数组
* arr: 数组名字,符合标识符规则
*
* 右半部分:
* new: 就是为数组在堆内存中开辟一个内存空间
* int: 表示数组中存放元素的数据类型是int类型
* []: 表示是一个数组
* 3: 表示数组中最多可以存放元素的个数(数组本身的长度)
* ;: 表示一个语句的结尾
*
*/
int[] arr = new int[3];
//[I@4554617c arr数组在堆内存中的地址值,地址是一个十六进制的形式。
System.out.println(arr);
//我们仅仅获取的是一个地址值是没有任何意义的,
//我们更期望获取的是数组中的元素
//如何获取数组中的元素呢?
//java在数组中提供了一个类似于下标的说法,我们可以通过下标获取到该下标位置上的元素
//这个下标有一个专业的叫法:索引(index)
//从左往右编号,从0开始
// 举例:现在数组的长度是3,索引从0开始,最大可以到2,也就是长度-1
// 获取数组元素的格式:数组名[想要获取元素的对应索引]
System.out.println(arr[0]); //获取第一个元素 0
System.out.println(arr[1]); //获取第二个元素 0
System.out.println(arr[2]); //获取第三个元素 0
}
}
2、如何给数组中的元素进行赋值呢?
通过数组中的索引给元素进行赋值
public class ArrayDemo2 {
public static void main(String[] args) {
//定义一个数组并动态初始化
//定义一个存放int元素类型的数组,最多可以存放3个。
int[] arr = new int[3];
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("============================");
//手动赋值
//给数组中第一个元素进行赋值
arr[0] = 10;
//给数组中第二个元素进行赋值
arr[1] = 20;
//给数组中第三个元素进行赋值
arr[2] = 30;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
3、定义两个数组并赋值输出数组名和元素值
public class ArrayDemo3 {
public static void main(String[] args) {
//定义第一个数组
int[] arr1 = new int[3];
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println("============================================");
//定义第二个数组
int[] arr2 = new int[4];
arr2[0] = 100;
arr2[1] = 200;
arr2[2] = 300;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
}
}
4、定义两个数组,先定义一个数组,赋值,输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值,再次输出两个数组的名及元素。
public class ArrayDemo4 {
public static void main(String[] args) {
//定义第一个数组
int[] arr1 = new int[3];
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
//定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
int[] arr2 = arr1;
arr2[0] = 100;
arr2[1] = 200;
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
}
}
5、
一维数组的静态初始化:初始化时指定每个数组元素的初始值,由JVM决定数组长度。(JVM根据我们给的元素个数自动推断长度)
静态初始化的语句格式:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,元素4...};
举例:int[] arr = new int[]{11,22,33,44,55};
表示的是定义一个存放5个int类型元素的数组,元素分别是11,22,33,44,55
简化写法:
数据类型[] 数组名 = {元素1,元素2,元素3,元素4...};
举例:int[] arr = {100,200,300,400};
表示的是定义一个存放4个int类型元素的数组,元素分别是100,200,300,400
public class ArrayDemo5 {
public static void main(String[] args) {
//定一个数组并静态初始化
int[] arr = {100,200,300,400};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
}
}
6、数组中常见的错误:
(1)、ArrayIndexOutOfBoundsException: 5 数组索引越界异常
访问了不该访问的索引。
(2)、NullPointerException 空指针异常
public class ArrayDemo6 {
public static void main(String[] args) {
//定义一个数组,静态初始化
int[] arr = {11,22,33,44,55};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
// System.out.println(arr[5]);
arr = null;
System.out.println(arr[0]);
}
}
7、数组遍历(依次输出数组中的每一个元素)
public class ArrayDemo7 {
public static void main(String[] args) {
//定义一个数组并动态初始化
// int[] arr = new int[3]{11,22,33};
//注意动态初始化不能与静态初始化混合使用!!
int[] arr = new int[8];
//手动获取每个元素并赋值
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
arr[3] = 44;
arr[4] = 55;
arr[5] = 66;
arr[6] = 77;
arr[7] = 88;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
// System.out.println(arr[8]);
System.out.println("=======用for循环改进========");
for(int i=0;i<=7;i++){
System.out.println(arr[i]);
}
System.out.println("=======用for循环改进2=======");
//由于上面的数组我们一眼就可以数清有多少个元素,所以在循环的时候,可以确定一个范围
//但是呢,真正的开发中,数组中的元素远远不止这么点,可能会有很多
//这时候我们再去数的话,不仅会数错,而且消耗大量时间
//那怎么办?我想要用for循环,就必须得确定一个范围
//如果有一个办法可以获取数组的长度就好了
//java中数组提供了一个属性供我们使用,可以获取数组的长度
//这个属性叫做:length
//使用格式:数组名.length
//当长度可以确定后,for循环的索引范围就能确定了:length-1
int[] arr2 = {100,20,3,132,4232,413,132,434241,3213,21,312,321,3,213,213,21,32,3,435,4,5,43,3245,3,4,342343,2,423,43,4,324,265,5,645};
// int length = arr2.length;
// System.out.println(length);
// [100,20,3....]
for(int i=0;i<arr2.length;i++){
if(i==0){
System.out.print("["+arr2[i]+",");
}else if(i==arr2.length-1){
System.out.print(arr2[i]+"]");
}else {
System.out.print(arr2[i]+",");
}
}
//\r\n是windows中的换行符
System.out.println("\r\n======将打印数组封装成一个方法==========");
printArray(arr2);
}
/**
* 定义遍历数组的方法
* 返回值类型:void
* 参数列表:int[] arr
*
*/
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==0){
System.out.print("["+arr[i]+",");
}else if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else {
System.out.print(arr[i]+",");
}
}
}
}
8、数组获取最值(获取数组中的最大值最小值)
public class ArrayDemo8 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
//思路:任意取一个值,假设它就是最大值
//然后拿着这个值与其余的值做比较,如果说遇到了比它还大的值,将该值作为临时最大值,当遍历完之后,获取到真正的最大值
//一般情况下,取第一个元素为最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
System.out.println("数组中最大值为:" + max);
System.out.println("==============用方法改进==============");
int maxNumber = getMaxNumber(arr); //0x001
System.out.println("数组中最大值为:" + maxNumber);
}
/**
* 定义一个获取数组最大值的方法
* 返回值类型:int
* 参数列表:int[] arr
*/
public static int getMaxNumber(int[] arr1){ //0x001
int max = arr1[0];
for (int i = 1; i < arr1.length; i++) {
if (arr1[i] > max) {
max = arr1[i];
}
}
return max;
}
}
9、数组元素逆序 (就是把元素对调)
public class ArrayDemo9 {
public static void main(String[] args) {
int[] arr = {43,31,123,1,21};//{43,31,123,1,21} ==> {21,1,123,32,43}
System.out.print("数组逆序之前:");
printArray(arr);
//将0索引位置的元素与length-1位置上的元素进行交换
//将1索引位置的元素与length-1-1位置上的元素进行交换
//直到length/2
int temp = arr[0];
arr[0] = arr[arr.length-1];
arr[arr.length-1] = temp;
int temp2 = arr[1];
arr[1] = arr[arr.length-1-1];
arr[arr.length-1-1] = temp2;
//调用方法遍历数组
System.out.print("\r\n数组逆序之后:");
printArray(arr);
System.out.println("\r\n==================用for循环改进实现数组逆序1:==================");
int[] niXuArray1 = niXu(arr);
printArray(niXuArray1);
// System.out.println("\r\n==================用for循环改进实现数组逆序2(创建新的数组):==================");
// int[] niXuArray2 = niXu2(arr);
// printArray(niXuArray2);
System.out.println("\r\n==================用for循环改进实现数组逆序3(定义指针):==================");
int[] niXuArray3 = niXu3(arr);
printArray(niXuArray3);
}
/**
* 定义方法实现数组的逆序(方法3)指针
* 返回值类型:int[]
* 参数列表:int[] array
*
*/
public static int[] niXu3(int[] array){
for(int start=0,end=array.length-1;start<=end;start++,end--){
int temp = array[start];
array[start] = array[end];
array[end] = temp;
}
return array;
}
/**
* 定义方法实现数组逆序(方法2)
* 返回值类型:int[]
* 参数列表:int[] array
*
* 这种方式不推荐:
* 1、由于创建了新的数组,开辟了新的堆内存空间,这样会造成内存资源浪费
* 2、题目本来的意思,在原数组上做逆序
*
*/
public static int[] niXu2(int[] array){
int[] arr2 = new int[array.length];
for(int i=array.length-1;i>=0;i--){
arr2[arr2.length-1-i] = array[i];
}
return arr2;
}
/**
* 实现数组逆序的方法(第一种方式实现)
* 返回值类型:int[]
* 参数列表:int[] array
*
*/
public static int[] niXu(int[] array){
for(int index=0;index<array.length/2;index++){
int temp = array[index];
array[index] = array[array.length-1-index];
array[array.length-1-index] = temp;
}
return array;
}
/**
* 定义遍历数组的方法
* 返回值类型:void
* 参数列表:int[] arr
*
*/
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==0){
System.out.print("["+arr[i]+",");
}else if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else {
System.out.print(arr[i]+",");
}
}
}
}
10、数组查表法(根据键盘录入索引,查找对应星期)
import java.util.Scanner;
public class ArrayDemo10 {
public static void main(String[] args) {
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
boolean flag = true;
while (flag) {
System.out.println("请输入数据(1-7):");
int number = sc.nextInt();
if (number >= 1 & number <= 7) {
System.out.println(week[number - 1]);
} else if (number == 0) {
flag = false;
} else {
System.out.println("输入的数据有误,请重新输入!");
}
}
}
}
11、数组元素查找(查找指定元素第一次在数组中出现的索引)
举例:{12,32,12,43,53,32,100,12} 32在数组中第一次出现的索引为1
import java.util.Scanner;
public class ArrayDemo11 {
public static void main(String[] args) {
//定义一个数组并静态初始化
int[] arr = {12,32,12,43,53,32,100,12};
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的元素:");
int number = sc.nextInt();
for(int i=0;i<arr.length;i++){
if(arr[i]==number){
System.out.println(number+"2在数组中第一次出现的索引为"+i);
//正确做法是查找到对应元素后,应该结束整个循环
break;
}
if(i==arr.length-1 && arr[arr.length-1]!=number){
System.out.println("您要查找的元素"+number+"不在数组中!");
}
}
}
}