JAVA程序设计----数组基础

一些小思考题:

1.什么时候为数组分配内存?
数组在初始化时分配内存

2.数组一旦被创建，大小能不能改变?
数组一旦被创建，它的大小就不能改变，可以使用array.length的得到数组的大小。
int[] list;
list = new int[10];//初始化数组
list = new int[20];//重新给数组变量赋值，而不是改变原数组的大小

3.实参是如何传递给方法的?实参可以和形参同名吗?
调用方法时，程序给形参分配存储空间，将实参的值赋给形参。
形参是局部变量，与实参不在同一个作用域，因此，能同名。

4.什么是方法的重载?能根据方法的修饰符或返回值类型进行重载吗?
方法重载：方法名相同，参数列表(参数类型、参数顺序和参数数量)不同
不能根据方法的修饰符或返回值类型进行重载。因为方法调用可作为一个值来处理，
也可作为语句处理，如：int val=fun()和fun(),当作为语句处理时，编译器不能区分
应该调用谁。

关于数组基础的一些编程题。

1.写一个函数，计算一个整数数组的平均值

public class threeA {
    public static void main(String[] args) {
        int[] list = {1,2,1,3,3};
        ave(list);
    }
    public static void ave(int[] list){
        int sum = 0;
        int res;
        for (int i = 0; i < list.length; i++) {
            sum = sum + list[i];
        }
        res = sum / list.length;
        System.out.println(res);
    }
}

2.自定义一个整数数组a,读入一个整数n,如果n在数组中存在，
* 则输出n的下标；如果不存在，输出-1；(*)

import java.util.Scanner;

public class threeB {
    public static void main(String[] args) {
        int[] array = {1,2,6,8,9};
        System.out.println("请输入一个你要查询的整数n:");
        Scanner scanner = new Scanner(System.in);
        int s = scanner.nextInt();
        boolean bool = true;
        for (int i = 0; i < array.length; i++) {
            if (s == array[i]){
                System.out.println("数组下标为："+i);
                bool = false;
                break;
            }
        }
        if(bool){
            System.out.println(-1);
        }
    }
}

3.输出一个给定数组的最大最小值。

public class threeC {
    public static void main(String[] args) {
        int[] array = {1,6,9,87,5,4};
        int max = 0;
        int min = 0;
        max = min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i]>max){
                max = array[i];
            }
            if (array[i]import java.util.Arrays;
public class threeD {
    public static void main(String[] args) {
        int[] arr = {2,5,9,6,7};
        for (int i = 0; i < arr.length/2; i++) {
        //arr.length/2,如果循环arr.length次，则又回到之前的数组
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-i-1] = temp;
        }
        System.out.println(Arrays.toString(arr));//Arrays.toString(arr)打印数组
    }
}

5.冒泡排序

public class threeE {
    public static void main(String[] args) {
        int[] a = {1,3,2,7,5};
        int len = a.length;
        for (int i = 0; i a[j+1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        for (int c: a){
            System.out.print(c+",");
        }
    }
}

6.插入排序

public class threeG {
    public static void main(String[] args){
        int[] arr = {6,8,9,1,4,3};
        int len = arr.length;
        for(int i = 1; i < len; i++){
            int temp = arr[i]; //记录操作数
            int j = 0;
            for(j = i - 1; j >= 0; j--){
                if(arr[j] > temp){
                    arr[j+1] = arr[j];
                }else{
                    break;
                }
            }
            if(arr[j+1] != temp){
                arr[j+1] = temp;
            }
        }
        for(int n : arr){
            System.out.print(n+",");
        }
    }
}

7.数组的基本工具

import java.util.Arrays;
public class threeF{
    public static void main(String[] args){
        int[] num = {45,65,75,87,98,901};
        //二分查找
        int index = Arrays.binarySearch(num,98);
        System.out.println("找到的下标是" + index);

        //输出数组
        for(int n : num){
            System.out.println(n);
        }
        System.out.println(Arrays.toString(num));
        Arrays.sort(num);

        //排序
        int[] num2 = {10,32,15,9,564,31};
        Arrays.sort(num2);//快速排序
        System.out.println(Arrays.toString(num2));

        //数组的复制
        int[] num3 = Arrays.copyOf(num2,10);
        System.out.println(Arrays.toString(num3));

        //
        int[] newNum = new int[num2.length];
        System.arraycopy(num2,0,newNum,0,num2.length);
        System.out.println(Arrays.toString(newNum));

        //小结，数组的复制
		/*
			效率由高到低排序是：
			System.arraycopy->Arrays.copyOf->for
		*/

        //判断两个数组的值是否相等
        System.out.println(Arrays.equals(num2,newNum));

        //填充数组
        Arrays.fill(newNum,0);
        System.out.println(Arrays.toString(newNum));
    }
}

8.最大公约数，最小公倍数

import java.util.Scanner;

public class threebyone {
    public  int mincom(int m,int n){
        int temp;
        int t = 0;
        if(m

9.计算字符数组中字母出现的次数and字符串中字母出现次数

import java.util.Scanner;
public class threebytwo {
    public static void main(String[] args) {

        char[] chs = {'a','a','d','c','a','b'};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的字符：");
        //Scanner输入，转化为char类型
        char c = scanner.next().charAt(0);//charAt返回指定位置的char值
        int count = 0;
        for (int i = 0; i < chs.length; i++) {
            if (chs[i] == c){
                count++;
            }
        }
        System.out.println("a出现的次数是:"+count);
        /**
         * 字符串中字母出现次数
         */
//        Scanner scanner = new Scanner(System.in);
//        System.out.println("请输入你的字符：");
//        String str = scanner.nextLine();
//        System.out.println(str);
//        System.out.println("请输入一个你需要统计的字母：");
//        Scanner scanner1 = new Scanner(System.in);
//        String c = scanner1.nextLine();
//        int count = 0;
//        int start = 0;
//        //indexOf返回指定子字符串在此字符串中第一次出现处的索引
//        while(str.indexOf(c,start) >= 0 && start < str.length()){
//            count++;
//            start = str.indexOf(c,start) + c.length();
//        }
//        System.out.println(c+"出现的次数是："+count);
    }
}