梅庄

java语言程序设计(基础篇+进阶篇)读书笔记1

发表于 | 分类于
第6章和第7章读书小结(字符串&一维数组）

Chapter 6 方法

生成随机字符

0<= Math.random<1
char型操作数与数字或字符运算，那么char型操作数会被转换成数字

1
2
System.out.println((char)('a'+Math.random()*('z' - 'a' +1)));
System.out.println(('a'+Math.random()*('z' - 'a' +1)));

输出如下：

Chapter 7 一维数组

声明数组

1
double[] myList

不同于基本数据类型变量的声明，声明一个数组变量时并不在内存中给数组分配任何空间。它只是创建一个对数组的引用的存储位置。如果变量不包含对数组的引用，那么这个变量的值为null

初始化

1
myList = {1.9,2.9,3.4,3.5}

随机打乱

1
2
3
4
5
6
7
8
9
10
        /*Shuffling*/
        for(int i = 0; i<myList.length; i++)
        {
//            Generate an index j randomly with 0<=j<=i
            int j = (int)(Math.random()*myList.length);
//            Swap
            double tmp = myList[i];
            myList[i] = myList[j];
            myList[j] = tmp;
         }

数组的复制

list2 = list1
该句并不能将list1引用的数组内容复制给list2，而只是将list1的引用值复制给了list2
即将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使得两个变量都指向相同的内存地址

复制数组有三中方法
1）使用循环语句逐个地复制数组的元素
2）使用System类的静态方法arraycopy
3）使用clone方法复制数组
比如使用arraycopy
arratcopy(sourceArray, srcPos, targetArray, tarPos, length
其中参数srcPos和tarPos分别表示在原数组sourceArray和目标数组targetArray的起始位置，复制的元素个数由参数length指定

1
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

将数组传递给方法

使用匿名数组

1
printArray(new int[]{3,2,4,6,7,8});

注意：
传递基本数据类型值与传递数组引用变量给方法的不同之处

两种swap方法

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void swap(int n1, int n2)
{
    int tmp = n1;
    n1 = n2;
    n2 = tmp;
}
public static void swapFirstTwoInArray(int[] array)
{
    int tmp = array[0];
    array[0] = array[1];
    array[1] = tmp;
}

使用swap方法诶能交换两元素。但是，使用swapFirstTwoInArray方法就实现了对换。因为调用swap(a[0], a[1])时，a[0]和a[1]的值传给了方法内部的n1和n2。n1和n2的内存位置独立于a[0]和a[1]的内存位置。这个方法的调用没有影响数组的内容

反转数组

1
2
3
4
5
6
7
8
9
public static int[] reverse(int[] list)
{
    for (int i = 0, j = list.length - 1; i < list.length / 2; i++, j--) {
        int temp = list[i];
        list[i] = list[j];
        list[j] = temp;
    }
    return list;    //从方法中返回数组的时候，返回数组的引用
}

二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int binarySearch(int[] list, int key)
{
    int left = 0;
    int right = list.length - 1;
    int mid;
    while(right >= left)
    {
        mid = left + (right - left)/2;
        if (key == list[mid])   return mid;
        else if(key < list[mid])    right = mid -1;
        else    left = mid + 1;
    }
    return -1;  //not found
}

Arrays类

在引入java.util.Arrays之后

Sort

对数组进行升序排列

1
2
Arrays.sort(array);
Arrays.parallelSort(array);

这里array为上面数组的引用，如果计算机有多个处理器，那么parallelSort将更加有效

对数组进行降序排列

1
2
String[] stringArray = {"a", "b", "c"};
Arrays.sort(stringArray, Collections.reverseOrder());

为了对java数组实现降序排序，你需要提供一个外部的Comparator
来对元素按相反的顺序排序。
不过，java的api中给我们提供了java.util.Collections.reverseOrder()方法，该方法返回一个与自然顺序相反的comparator。将这个comparator作为参数传给sort方法，就可以实现降序排序了。（不过好像int的基础类型的不可以，String类型的没问题，T[]）
当然也可以先将数组转换为ArrayList，然后调用ArrayList的reverse()方法，再转换为数组。不过最好还是使用Arrays.sort()方法。

对数组中的子数组进行排列

1
Arrays.sort(list3, 0, 2);

Arrays类提供了对数组的部分元素进行排序的方法。例如，你可能有一个很多的数组，而你只需要对于特定的一段进行排序，那么可以使用java.util.Arrays.sort(array,index,index) ，它只会对指定范围内的元素进行排序。这比对整个数组进行排序要快。

binarySearch

在数组中查找关键字。数组必须提前按升序排列好。如果数组中不存在关键字，方法返回-（插入点下标+1）

equals

equals方法检测两个数组是否相等。如果内容相同，那么这两个数组相等

1
2
3
4
5
int[] list1 = {2,4,7,10};
int[] list2 = {2,4,7,10};
int[] list3 = {4,2,7,10};
System.out.println(Arrays.equals(list1,list2)); //true
System.out.println(Arrays.equals(list1, list3));//false

fill

fill方法填充整个数组或部分数组

1
2
Arrays.fill(list1,5);   //5，5，5，5
Arrays.fill(list2, 1, 3, 5 );   //2，5，5，10

toString

使用toString方法返回一个字符串，该字符串代表了数组中的所有元素

1
System.out.println(Arrays.toString(list3)); //[4, 2, 7, 10]

其他

将数组参数传递给方法时，实际上传递的是数组的医用；更准确地说，被调用的方法可以修改调用者的原始数组的元素。