Java基础-02

Java基础-02

Scanner对象实现用户交互

使用next获取：

// 创建Scanner对象
Scanner scanner = new Scanner(System.in);

System.out.println("使用next获取：");
// 判断是否有输入
if(scanner.hasNext()){
    // 使用next获取
    String s = scanner.next();
    System.out.println("输入的内容为："+s);
}
// 关闭Scanner对象（属于IO流的类都需要关闭）
scanner.close();

使用nextline获取：

// 创建Scanner对象
Scanner scanner = new Scanner(System.in);

System.out.println("使用nextline获取：");
// 判断是否有输入
if(scanner.hasNextLine()){
    // 使用next获取
    String s = scanner.nextLine();
    System.out.println("输入的内容为："+s);
}
// 关闭Scanner对象（属于IO流的类都需要关闭）
scanner.close();

next和nextline的区别：

• next方式
  • 不能得到带有空格的字符串。对输入有效字符之前的空白，会自动将其去掉。
• nextLine方式
  • 以Enter键为结束符，换句话说就是可以得到敲Enter键前的全部字符，包括空格。

还可以控制输入数据的类型，例如：

Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数：");
if(scanner.hasNextInt()){
    int i = scanner.nextInt();
    System.out.println("输入的整数为："+i);
}else {
    System.out.println("输入的不是整数！！");
}

流程控制结构

Java流程控制结构有：顺序结构、选择结构、循环结构。

顺序结构就是从上到下，依次执行语句。

选择结构有if选择和switch选择。下面是switch结构：

Scanner scanner = new Scanner(System.in);
String s = scanner.next();
switch (s){
    case "A":
        System.out.println("优秀！");
        break;
    case "B":
        System.out.println("及格");
        break;
    case "C":
        System.out.println("不及格！");
        break;
    default:
        System.out.println("请输入ABC！");
}
scanner.close();

循环结构有：while循环、do while循环、for循环 3种；

while循环和do while循环的区别是：当条件不满足，while循环一次也不执行，而do while循环还会执行一次。

练习：打印99乘法表：

for (int i = 1; i <= 9; i++) {
    for(int j = 1; j<=i; j++){
        System.out.print(i+"*"+j+"=" +i*j+"\t");
    }
    System.out.println();
}

输出结果：
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

Java5之后引入了一种增强for循环：例如

int[] ints = {1,2,3,4};
for (int i : ints) {
    System.out.println(i);
}

break和continue的区别

• break：用在switch选择结构，或者循环结构中来中止循环。
• continue：用在循环结构中，用来跳过本次的循环。不会中止整个循环。

for (int i = 1; i <= 100; i++) {
    if(i%10==0){
        System.out.println();
        continue;
    }
    System.out.print(i+"\t");
}

输出结果：
1	2	3	4	5	6	7	8	9	
11	12	13	14	15	16	17	18	19	
21	22	23	24	25	26	27	28	29	
31	32	33	34	35	36	37	38	39	
41	42	43	44	45	46	47	48	49	
51	52	53	54	55	56	57	58	59	
61	62	63	64	65	66	67	68	69	
71	72	73	74	75	76	77	78	79	
81	82	83	84	85	86	87	88	89	
91	92	93	94	95	96	97	98	99	

Java的方法

方法的重载：方法名字相同，参数不同。返回类型可以相同，可以不同。

可变参数：在指定参数类型后加一个省略号（...）;一个方法中只能有一个可变参数，且只能是最后一个参数。 例如下面：

public static void main(String[] args) {
    System.out.println(add(1,2,3)); //输出6
    System.out.println(add(1,2,3,4,5)); //输出15
}
public static int add(int... ints){
    int s = 0;
    for (int i : ints) {
        s = s+i;
    }
    return s;
}

递归

方法调用本身称为：递归。也就是自己调用自己。

递归包含两个部分：递归头、递归体。

• 递归头：什么时候不能调用本身。如果没有就会陷入死循环。
• 递归体：什么时候需要调用本身。

面试题：使用递归实现阶乘的求解。

public static void main(String[] args) {
    System.out.println(f(3));
}

public static int f(int n){
    if(n == 1){
       return 1;
    }
    return f(n-1)*n;
}

Java数组

数组是相同数据类型的集合。数组内的元素通过下标来访问。

数组的大小是确定的，一旦创建，大小就不可以改变。

数组内元素可以是任意类型。包括基本数据类型和引用数据类型。

int[] ints1 = {1,2,3,4,5};
// 通过下标来取值，
int i1 = ints1[0];
int i2 = ints1[1];
// 获取数组的长度
int length = ints1.length;
System.out.println("数组的长度："+length);
// 遍历
for(int i=0; i<ints1.length; i++){
    System.out.print(ints1[i]+"\t");
}
System.out.println();
for(int i: ints1){
    System.out.print(i+"\t");
}

数组的初始化有两种方式：静态初始化、动态初始化。

// 静态初始化：声明+赋值
int[] a = {1,2,3};   
// 动态初始化
int[] a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;  //如果不赋值，会默认初始化为0；

面试题：反转一个数组。

public static int[] reverse(int[] ints){
    int[] result = new int[ints.length];
    for (int i = ints.length-1,j = 0; i>=0; i--,j++){
        result[j] = ints[i];
    }
    return result;
}

在Java中，提供了有关数组操作的类，为Arrays类，在Arrays类中封装了常用的数组的操作。

int[] a = {2,1,4,3,5};
System.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println(Arrays.toString(a));

输出结果：
    [2, 1, 4, 3, 5]
	[1, 2, 3, 4, 5]

有关数组的排序算法有很多种，常见的如：冒泡排序。如下：

public static void sort(int[] ints){
    int temp = 0;
    for(int i = 0; i < ints.length-1; i++){
        for(int j = 0; j < ints.length-1-i; j++){
            if(ints[j]>ints[j+1]){
                temp = ints[j];
                ints[j] = ints[j+1];
                ints[j+1] = temp;
            }
        }
    }
}