大数据学习2019.03.14

数组，分支，循环语句练习

Java白皮书的关键术语

简单性，面向对象，网络技能，健壮性，安全性，体系结构中立，可移植性，解释型，高性能，多线程，动态性。

1.输入一个数求该数是不是质数

import java.util.Scanner;
public class Test01
{
    public static void main(String[] args){
    
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();

        int i = 2;
        while(i<num){
            if (num%i == 0)
            {
                break;
            }
            i++;
        }
        if (num == i)
        {
            System.out.println(num+"是一个质数！");
        }else{
            System.out.println(num+"不是一个质数！");
        }

    }
}

2.判断一个年份是否是闰年。

public class Test02{

    public static void main(String[] args){
        OUT:
        for(int i = 1;i<=5;i++){
            for(int j = 1;j<=3;j++){
                //System.out.println("("+i+","+j+")");
                if(i == 2){
                    break OUT;
                }
                System.out.println("("+i+","+j+")");
            }
        }    
    }
}

3.输入一个整数求他的逆序数。

import java.util.Scanner;
public class Test07{

    /*
     *输入一个整数求他的逆序数
     */
    public static void main(String[] args){
    
        Scanner in = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = in.nextInt();
        int revNum = 0;
        int oriNum = num;
        while(num/10!=0|num>0){
            revNum = revNum*10 + num%10;
            num = num/10;
        }
        System.out.println(oriNum + "的逆序数为：" + revNum);

    }
}

4.求100到999内的水仙花数。

public class Test08  {
    public static void main(String[] args){
        /*
        *求100到999内的水仙花数；
        *
        */
        int a = 0,b = 0,c = 0;
        for (int i = 100;i<=999 ;i++ ){
            a = i/100;
            b = i/10%10;
            c = i%10;
            if(a*a*a+b*b*b+c*c*c == i){
                System.out.println(i);
            }
        }
    }
}

5.冒泡排序。

import java.util.Scanner;
public class Test10{
    
    //冒泡排序
    public static void main(String[] args){
    
        int[] arr = new int[10];
        Scanner in = new Scanner(System.in);
        System.out.print("请输入10个整数：");
        for(int i = 0;i<10;i++){
            arr[i] = in.nextInt();
        }
        for(int i = 0;i<arr.length;i++){
            for (int j = i+1;j<arr.length ;j++ )
            {
                if(arr[i]>arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        for(int k:arr){
            System.out.print(k+" ");
        }

    }
}

6.猜数字游戏。

import java.util.Scanner;
public class Test12 {
    public static void main(String[] args) {
        System.out.println("猜数字小游戏");
        Scanner in = new Scanner(System.in);
        int res = (int)(Math.random()*100+1);
        while(true){
            System.out.print("请猜数字1到100：");
            int num = in.nextInt();
            if (res>num){
                System.out.println("小了");
            }else if(res<num){
                System.out.println("大了");
            }else{
                System.out.println("猜中了");
                break;
            }
        }
    }
}

7.判断素数进阶。

 

package test01;

import java.util.Scanner;

public class PrimeTest01 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int x = in.nextInt();
        boolean isPrime = true;
        if (x == 1 || x % 2 == 0 && x != 2) {
            isPrime = false;
        } else {
            for (int i = 3; i < Math.sqrt(x); i += 2) {
                if (x % i == 0) {
                    isPrime = false;
                    break;
                }
            }
        }
        if (isPrime) {
            System.out.println(x + "是一个素数！");
        } else {
            System.out.println(x + "不是一个素数！");
        }
        in.close();

    }

}

 

8.判断素数进阶二。

判断是否能被已知且<x的素数整除。

实例：求前50个素数

package test01;

import java.util.Scanner;

public class PrimeTest01 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] primes = new int[50];
        primes[0] = 2;
        int cnt = 1;
        OUT: for (int x = 3; cnt < 50; x++) {
            for (int i = 0; i < cnt; i++) {
                if (x % primes[i] == 0) {
                    continue OUT;
                }
            }
            primes[cnt++] = x;
        }
        for (int k : primes) {
            System.out.print(k + " ");
        }
        in.close();
    }
}

9.构造素数表

构造n以内的素数表

package test01;

public class PrimeTest02 {
    public static void main(String[] args) {
        boolean[] isPrime = new boolean[100];
        for (int i = 0; i < isPrime.length; i++) {
            isPrime[i] = true;
        }
        for (int i = 2; i < isPrime.length; i++) {
            if (isPrime[i]) {
                for (int k = 2; i * k < isPrime.length; k++) {
                    isPrime[i * k] = false;
                }
            }
        }
        for (int i = 2; i < isPrime.length; i++) {
            if (isPrime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

二维数组

int[][] arr = new int[3][5];

二维数组的遍历。

package test01;

public class ArrayTest {

    public static void main(String[] args) {

        int[][] arr = new int[3][5];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i * j;
            }
        }

    }

}

 

字符串变量

String s;

String是一个类，String的变量是对象的管理者而非所有者；

字符串的初始化

 

String s = new String("a string");
String s1 = "Hello";

 

字符串连接：用加号（+）可以连接两个字符串；

输入字符串

in.next();读入一个单词，单词的标志是空格（空格包括空格，tab，和换行）；

in.nextLine();读入一整行。

Strings应该用.equals来比较。

字符串操作

获得String的长度用length()函数。

访问String里的字符

s.charAt(index)

返回在index上的单个字符

不能用for-each循环来遍历字符串。

得到子串

s.substring(n);得到从n号位置到结尾的全部内容；

s.substring(b,e);得到从b到e之前的内容。

寻找字符

s.indexOf(c);得到c字符所在的位置，-1表示不存在；

s.indexOf(c,n);从n开始寻找c字符

s.indexOf(t);找到字符串t所在的位置。

s.lastIndexOf();从右边开始找。

注：所有的字符串都是不可变的，对它们的操作的结果都是制造新的字符串出来。

函数定义

函数是一块代码，接收零个或多个参数，做一件事，并返回零个或一个值。

return：停止函数的执行，并返回零个或一个值

没有返回值得函数

• void 函数名(参数表)
• 不能使用带值的return；
• 可以没有return
• 调用的时候不能做返回值的赋值 

传值

每个函数有自己的变量空间，参数也位于这个独立的空间中，和其他函数没有关系。

对于函数参数表中的参数，叫做参数，调用函数时给的值，叫做实际值。

本地变量

• 函数的每次运行，就产生了一个独立的变量空间，在这个空间中的变量，就是函数的这次运行独有的，称作本地变量。
• 定义在函数内部的变量就是本地变量。
• 参数也是本地变量

本地变量的规则

• 本地变量是定义在块内的
• 它可以定义在函数的块内
• 也可以定义在语句的块内
• 甚至随便拉一对大括号来定义变量
• 程序运行进入这个块之前，其中的变量不存在，离开这个块，其中的变量就消失了。
• 块外面定义的变量依然有效
• 不能在一个块内定义同名的变量，也不能定义块外面定义过的变量。

Java的三种注释方式：

 

// 单行注释，其注释内容从//开始到本行结尾

/*
 *多行注释
 */

/**
 *多行注释，可以自动生成文档
 *
 */

 

注意：在Java中，/* */注释不能嵌套，如果代码本身包含了一个*/,就不能用/*和*/将注释括起来。