Java中数组的使用（第一篇）

Java中数组的使用（第一篇）

• 键盘输入5个整数，存到一个数组中
• 计算所有元素的和，最大值，最小值和平均值

/**
 * 键盘输入5个整数，存到一个数组中
 * 计算所有元素的和，最大值，最小值和平均值
 */
import java.util.Scanner;

public class IntArray {
    public static void main(String[] args){
        int [] array = new int [5] ;
        Scanner input = new Scanner(System.in) ;

        for(int i=0; i<5; i++){
            array[i] = input.nextInt() ;
        }

        int max = array[0], min = array[0], sum = 0 ;
        double average = 0.0 ;

        for(int j=0; j<array.length; j++){
            if(array[j] > max){
                max = array[j] ;
            }
            if(array[j] < min){
                min = array[j] ;
            }
        }
        for(int m : array){
            sum += m ;
        }
        average = sum / 5.0 ;
        System.out.println("最大值：" + max + "最小值：" + min + "总和：" + sum + "平均值：" + average) ;

     }
}

• 编写程序，使之产生1000个1-6的随机数，并统计每个数出现的次数

/**
 * 编写程序，使之产生1000个1-6的随机数，并统计每个数出现的次数
 */
public class RandomTest {
    public static void main(String[] args){
        int [] array = new int [6] ;
        for(int i=0; i<1000; i++){
            int number = (int)(Math.random() * 6) + 1 ; //产生1-6之间的随机数
            switch(number){
                case 1 : array[0] ++ ; break ;
                case 2 : array[1] ++ ; break ;
                case 3 : array[2] ++ ; break ;
                case 4 : array[3] ++ ; break ;
                case 5 : array[4] ++ ; break ;
                case 6 : array[5] ++ ; break ;
            }
        }
        for(int i=0;i<array.length; i++){
            System.out.print(array[i] + " ") ;
        }
    }
}

• 编写一个方法，求double型数组的最小值

import java.util.Scanner;

/**
 * 编写一个方法，求double型数组的最小值
 */
public class ArrayDemo {
    public static double min(double [] array){ //求数组最小值的方法
        double min = array[0] ;
        for(int i=0; i<array.length; i++){
            if(min > array[i]){
                min = array[i] ;
            }
        }
        return min ;
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        System.out.print("请输入5个double型数：");
        double [] array = new double [5] ;
        for(int i=0; i<array.length; i++){
            array[i] = input.nextDouble() ;
        }
        System.out.println("最小值：" + min(array)) ;
    }
}

• 定义一个有10个元素的整形数组，将前5个元素与后5个元素进行互换
• 即将第一个元素与第10个元素互换，第2个元素与第9个互换，依次类推
• 输出原来数组的元素值和互换后的数组的元素值

/**
 * 定义一个有10个元素的整形数组，将前5个元素与后5个元素进行互换
 * 即将第一个元素与第10个元素互换，第2个元素与第9个互换，依次类推
 * 输出原来数组的元素值和互换后的数组的元素值
 */
import java.util.Scanner;
public class ArrayChange {
    public static void main(String[] args){
        int [] array = new int [10] ;
        Scanner input =  new Scanner(System.in) ;
        for(int i=0; i<array.length; i++){
            array[i] = input.nextInt()  ;
        }
        for(int m : array){ //输出原来的数组元素
            System.out.print(m + " ") ;
        }
        System.out.println() ;

        for(int j=0; j<array.length / 2 ; j++){ //交换数组元素
            int temp = array[j] ;
            array[j] = array[array.length-1-j];
            array[array.length-1-j] = temp  ;
        }
        for(int n : array){ //输出交换后的数组元素
            System.out.print(n + " ") ;
        }
    }
}

• 定义一个有8个元素的整形数组，使用选择排序法对数组进行升序排序

/**
 * 定义一个有8个元素的整形数组，使用选择排序法对数组进行升序排序
 */
public class ArraySort {
    public static void main(String[] args){
        int [] number = new int [] {3,1,-4,2,7,9,6,70} ;
        System.out.print("排序之前的数组元素：") ;
        for(int m : number){
            System.out.print(m + " ") ;
        }
        for(int i=0; i<number.length-1; i++){ //i趟排序
            int k = i ;
            for(int j=k+1; j<number.length; j++){
                if(number[k] > number[j]){ //找出每趟最小值的所在位置
                    k = j ;
                }
            }
            //交换
            if(i != k){
                int temp = number[i] ;
                number[i] = number[k] ;
                number[k] = temp ;
            }
        }
        System.out.print("排序后的数组元素：") ;
        for(int n : number){
            System.out.print(n + " ")  ;
        }
    }
}

• 使用非递归打印斐波那契数列的前20项
• 斐波那契数列第一个和第二个数都是1，以后每个数是前两个数字之和

/**
 * 使用非递归打印斐波那契数列的前20项
 * 斐波那契数列第一个和第二个数都是1，以后每个数是前两个数字之和
 */
public class Fibonacci {
    public static void main(String[] args) {
        int [] array = new  int [20] ;
        array[0] = 1 ;
        array[1] = 1 ;
        for(int i=2; i<array.length; i++){
            array[i] = array[i-1] + array[i-2] ;
        }
        for(int m : array){
            System.out.print(m + " ") ;
        }
    }
}

• 编写一个方法，计算两个一维数组元素之和，对应元素求和即可

import java.util.Arrays;

/**
 * 编写一个方法，计算两个一维数组元素之和，对应元素求和即可
 */
public class SumArray {
    public static int [] sumArray(int [] a, int [] b){
        int size = Math.max(a.length,b.length) ;
        int [] sum = new int [size] ;
        a = Arrays.copyOf(a,size) ; //元素复制存放到数组中
        b = Arrays.copyOf(b,size) ;
        for(int i=0; i<size; i++){
            sum[i] = a[i] + b[i] ;
        }
        return sum ;
    }
    public static void main(String[] args){
        int [] a = new int [] {1,2,4} ;
        int [] b = new int [] {2,4,6,8} ;
        int [] c = sumArray(a,b)  ;
       for(int i=0; i<c.length; i++){
           System.out.print(c[i] + " ") ;
       }
    }
}

• 编写一个方法，合并两个数组，并以升序返回合并后的值

import java.util.Arrays;
/**
 * 编写一个方法，合并两个数组，并以升序返回合并后的值
 */
public class ArrayMerge {
    public static int [] arrayMerge(int [] a, int [] b){
        int size = a.length + b.length ;
        int [] array = new int [size] ;
        for(int i=0; i<a.length; i++){
            array[i] = a[i] ;
        }
        for(int j=a.length; j<size; j++){
            array[j] = b[j-a.length] ;
        }
        Arrays.sort(array) ; //升序排列
        return array ;
    }
    public static void main(String[] args){
        int [] a =  new int [] {1,3,2,4,9,5,7} ;
        int [] b = new int [] {8,10,6} ;
        int [] result = arrayMerge(a,b) ;
        for(int i=0; i<result.length; i++){
            System.out.print(result[i] + " ") ;
        }
    }
}

• 编写求解二元一次方程的方法,输出方程组的根的个数

import java.util.Scanner;
/**
 * 编写求解二元一次方程的方法,输出方程组的根的个数
 *
 */
public class SolveQuadratic {
    public static int solveQuadratic(double [] eqn, double [] roots){
        double discriminant = eqn[1] * eqn[1] - 4 * eqn[0] * eqn[1] ;
        if(discriminant < 0){ //无根
            return 0 ;
        }
        else if (discriminant == 0){ //1个根
            roots[0] = - eqn[1] / (2 * eqn[0]) ;
            roots[1] = -eqn[1] / (2 * eqn[0]) ;
            return 1 ;
        }
        else{ //2个根
            roots[0] = (-eqn[1] + Math.sqrt(discriminant)) / (2 * eqn[0])  ;
            roots[1] = (-eqn[1] - Math.sqrt(discriminant)) / (2 * eqn[0]) ;
            return 2 ;
        }
    }
    public static void main(String[] args){
        double [] eqn = new double [3] ;
        double [] roots = new double [2] ;
        Scanner input = new Scanner(System.in) ;
        for(int i=0; i<eqn.length; i++){
            eqn[i] = input.nextInt() ;
        }
        System.out.println("方程组根的个数：" + solveQuadratic(eqn,roots)) ;
    }
}