0205基础语法

数组

• 数组是相同数据类型的多个数据的容器

数组的创建

// 创建数组的格式
//常用格式1：创建数组的同时指定数组中的内容
//数据类型[] 数组名称 = {数据1，数据2...}
int [] ages = {10,11,12,13,14};

//常用格式2：创建数组并指定长度，不指定数组内容
//数据类型[] 数组名你 = new 数据类型[数组长度];
//数组长度通过int数据指定
//默认值为0
int [] ages2 = new int[10];

//数组不常用的创建方式
//1.创建数组，不初始化
//格式：数据类型[] 数组名
int[] nums;
nums = new int[10];
//nums = {1,2,3,4};不能使用，只能在声明中使用

//2.创建数组并指定数组中的内容,不如直接指定
//格式：数据类型[] 数组名称 = new 数据类型[]{内容1，内容2...}
int[] ages = new int[] {11,12,13,14};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

数组创建问题

//1.数组下标越界问题：
int[] nums = {10,11,12,13,14};
System.out.println(nums[5]);

//2.空指针问题，只有名，没有值，被引用内存为空
int[] nums;
//解决方法1： int[] nums = null;
//解决方法2： static int[] nums;默认值是null
System.out.println(nums);

1
2
3
4
5
6
7
8
9
10

数组的遍历

//如何获取数组的长度:数组名称.length
for(int index=0;index<ages.length;index++) {
    System.out.println(ages[index]);
}
1
2
3
4

寻找最大值

int[] nums = {10,30,40,33,22,20,11,20};
//1.创建一个变量用于存储遍历数组中发现的最大值
int n = nums[0];
//2.循环取出数组中的每一个内容，从1开始
for(int i=1;i<nums.length;i++) {
    n = n>nums[i]?n:nums[i];
}
System.out.println(n);
1
2
3
4
5
6
7
8

冒泡排序

int[] nums = {20,15,18,13,30,60};
int temp;
//外层循环控制轮数
//次数为轮数-1
for(int i=0;i<nums.length;i++) {
    //第n轮（n轮）比较次数length-n-1
    for(int j=0;j<nums.length-i-1;j++) {
        //比较后交换 
        if(nums[j]>nums[j+1]) {
            temp = nums[j];
            nums[j] = nums[j+1];
            nums[j+1] = temp;
        }
    }
}

for(int i=0; i<nums.length;i++) {
    System.out.println(nums[i]);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

二分查找（折半查找）

• 二分查找(Binary Search)，他是一种效率较高的查找方法，但是必须采用顺序存储结构有序排列

• 假设升序排列，将数组中间位置的数据与查找数据比较，若两者相等，则查找成功，否则利用中间位置将数组分为前后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则查找后子数组。重复以上过程

• 流程：

  1. 确定查找范围：最小-最大
  2. 计算中间下标
  3. 比较中间下标数据，中间数据较大，则最大下标等于中间下标-1；
     比较中间下标较小，最小下标等于中间下标+1
  4. 当最小下标大于最大下标，查找失败

int[] nums = {10,20,30,40,50,60,70,80,90};
//要查找的数据
int num = 30;
//最小下标
int minIndex = 0;
//最大下标
int maxIndex = nums.length-1;
//中间下标
int centerIndex = (minIndex+maxIndex)/2;

while(true) {
    if(nums[centerIndex]>num) {
        maxIndex = centerIndex-1;
    }else if(nums[centerIndex]<num) {
        minIndex = centerIndex+1;
    }else {
        //找到了 数据位置centerIndex
        break;
    }
    
    if(minIndex>maxIndex) {
        centerIndex = -1;
        break;
    }
    //边界发生变化，需要更新中间下标
    centerIndex = (minIndex+maxIndex)/2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

多维数组

//创建二维数组
int[][] nums = new int[10][];
//赋值
nums[0] = new int[]{1,2,3};
//调用
System.out.println(nums[0][2]);
1
2
3
4
5
6

作业

//找队长
int [] members = new int[10];
    //成员报数
    int number = 0;
    //被排除人数
    int outNumber = 0;
    //成员编号数组的下标
    int memberIndex = 0;
    //备选队长位置
    int tempLeader = 0;
    while(true) {
        //跳过已经被排除的成员
        while(members[memberIndex]==3) {
            //首尾相连遍历数组
            memberIndex = (memberIndex+1)%members.length;
        }
        //以3为周期，成员报数
        number++;
        members[memberIndex] = number;
        //报数为3，排除该成员，报数清零
        if(number == 3) {
            outNumber++;
            number = 0;
        }else {
            //没有被排除的成员为备选队长
            tempLeader = memberIndex+1;
        }
        memberIndex = (memberIndex+1)%members.length;
        //当队伍中只剩一名成员，选为队长，跳出循环
        if(outNumber == members.length-1) {
            break;
        }
    }
    //打印队伍状态
    for(int i=0;i<members.length; i++) {
        System.out.print(members[i]+" ");
    }
    System.out.println();
    //打印结果
    System.out.println("队长为第"+tempLeader+"名成员");
        
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

随机数

//method1
import java.lang.Math;
...
//生成[0,1)之间的double,通过乘以最大值并强制类型转换,返回[0,max)之间的随机数
int d = Math.random();
i = (int)(d*max);

//输出100~1000之间的随机数
int min = 100;
int max = 1000;
int num = min + (int)(Math.random()*(max - min +1));

//method2
import java.util.Random;
...
Random rand = new Random();
//随机生成[0,max)
rand.nextInt(max);
//输出[min,max)之间的随机数
num = rand.nextInt((max - min) + 1) + min;

//method3
import java.util.concurrent.ThreadLocalRandom;
//随机生成[min,max)
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

参考网站

https://stackoverflow.com/questions/363681/how-do-i-generate-random-integers-within-a-specific-range-in-java

字符串比较

String myStr1 = "Hello";
String myStr2 = "Hello";
String myStr3 = "Another String";
System.out.println(myStr1.equals(myStr2)); // Returns true because they are equal
System.out.println(myStr1.equals(myStr3)); // false
1
2
3
4
5