day01

选择题：

1、如果 int x=20, y=5 ，则语句 System.out.println(x+y +""+(x+y)+y); 的输出结果是（D）

A: 2530
B: 55
C: 2052055
D: 25255

解答：

1）不论有什么运算，小括号的优先级都是最高的，先计算小括号中的运算，得到结果为
x+y +""+25+y

2）任何字符与字符串相加都是字符串，字符串前面的按原来的格式相加，但是中间有个空的字符串，java会把这个空字符串后面的都当成字符串看待，得到
25+""+25+5

3）上面的结果按字符串相加得到25255

考点：

1. 运算符的优先级
2. 打印的时候字符串的拼接 "+" 在String编译的时候把"+"号操作符替换成了StringBuilder 的 append 方法。也就是说，“+”号操作符在拼接字符串的时候只是一种形式主义，为了更加方便使用。

---

2、在java中，在同一包内，类Cat里面有个公有方法sleep()，该方法前有static修饰，则可以直接用Cat.sleep(A)。

A: 正确
B: 错误

解答：

static表示“全局” 或者 “静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块。

被static修饰的成员变量和成员方法独立于该类的任何对象，也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。

实际上，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表...)

① static变量

按照是否静态的对类成员变量进行分类可分两种：
一种是被static修饰的变量，叫静态变量或类变量；
另一种是没有被static修饰的变量，叫实例变量。

两者的区别是：

对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：

• 在对象之间共享值时
• 方便访问变量时

② 静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，

因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。

因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！

因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。

静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的

③ static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

④ static final

用来修饰成员变量和成员方法，可简单理解为“全局常量”！

对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

对于方法，表示不可覆盖，并且可以通过类名直接访问。

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main() 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：

• 它们仅能调用其他的static 方法。
• 它们只能访问static数据。
• 它们不能以任何方式引用this 或super

考点：

1. static关键字

---

3、给定以下方法声明，调用执行 mystery（1234） 的输出结果？(B)

//precondition: x >=0
public void mystery (int x) {
    System.out.print(x % 10);
    if ((x / 10) != 0){
        mystery(x / 10);
    }
    System.out.print(x % 10);
}

A: 1441
B: 43211234
C: 3443
D: 12344321

考点：

1. 对递归调用的理解

---

编程题：

1、实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。

leetcode-cn.com/problems/to…

题目分析：

在这道题中是一个字符串，我们需要遍历这个字符串，然后找到所有的大写字母改成小写字母。 首先，将大写改为小写有三种方法:

1. 给这个数加上一个s，即res += (char)s;
   
2. 给这个数加上32，即arr[i] += 32;
   
3. 采用位运算arr[i] |= 32;

之后我们来考虑怎么进行对这个字符串的遍历，分为三步
第一种：

1. 将字符串str转为字符数组； char[] arr = str.toCharArray();
2. 遍历字符数组，找到大写字母；
3. 将字符数组转回字符串类型； return new String(arr);

第二种：

1. 定义一个指针，拿到当前所指的这个元素（字符）
   char c = str.charAt(i);
2. 判断是否是大写字母
3. 定义一个字符串，拼接这个转变后的字符
   String result = "";
   result += c;

答案：

class Solution {
    public String toLowerCase(String str) {
        char[] arr = str.toCharArray();

        for(int i = 0;i < arr.length;i++) {
            if(arr[i] >= 'A' && arr[i] <= 'Z') {
                arr[i] += 32;
            }
        }
        return new String(arr);
    }
}

---

2、旋转数组：给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

leetcode-cn.com/problems/ro…

题目分析：

第一种思路：一般的双重循环来遍历数组，一个从前面开始循环，一个从后开始，一起遍历

for (int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for (int j = n - 1; j > 0; j--) {
                nums[j] = nums[j - 1];
            }
            nums[0] = temp;
        }

第二种思路：三次翻转可以得到，单独写一个翻转的方法调用三次
( 0, n - 1);
( 0, k - 1);
( k, n - 1);

第三种思路：循环交换

第四种：递归

import java.util.Arrays;

class Solution {
    /**
     * 双重循环
     * 时间复杂度：O(kn)
     * 空间复杂度：O(1)
     */
    public void rotate_1(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        for (int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for (int j = n - 1; j > 0; j--) {
                nums[j] = nums[j - 1];
            }
            nums[0] = temp;
        }
    }

    /**
     * 翻转
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_2(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }


    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }

    /**
     * 循环交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_3(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        // 第一次交换完毕后，前 k 位数字位置正确，后 n-k 位数字中最后 k 位数字顺序错误，继续交换
        for (int start = 0; start < nums.length && k != 0; n -= k, start += k, k %= n) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
        }
    }

    /**
     * 递归交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(n/k)
     */
    public void rotate(int[] nums, int k) {
        // 原理同上
        recursiveSwap(nums, k, 0, nums.length);
    }

    private void recursiveSwap(int[] nums, int k, int start, int length) {
        k %= length;
        if (k != 0) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
            recursiveSwap(nums, k, start + k, length - k);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}