Java基础(五)

关注

原创最新推荐文章于 2026-09-09 14:50:37 发布 508 阅读 AI 写同款· GEO 优化 ›

【信息系统项目管理师】第18章：项目绩效域详解 (3)度量绩效域与规划绩效域、项目工作绩效域和交付绩效域的相互作用:1规划构成了交付和规划比较的基础;项目绩效域共同构成了一个统一的整体，作为一个完整系统，在项目生命周期过程中运行，系统内的每个绩效域相互作用、相互关联和相互依赖，并协调一致、共同运作，支撑项目目标和价值的实现。(5)开发方法和生命周期绩效域与其他绩效域的相互作用:开发方法和生命周期绩效域与干系人绩效域、规划绩效域、不确定性绩效域、交付绩效域、项目工作绩效域和团队绩效域相互作用。(2)项目工作绩效域的绩效要点包括:项目过程; 阅读详情

@(MarkDown)[think in java|MarkDown]

1.数组

数组的特点

数组是一个连续的内存空间,存储了多个相同数据类型的数据,是对这些数据的统一管理;里面的元素可以是任何类型,包括基本类型和引用类型;
数组中的元素的变量是引用类型,数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量;
数组变量存放的是连续空间第一个元素的地址;
为什么数组下标要从0开始
- 数组是一段连续的空间，要求a[i]就是求它的地址，然后找到它。如果从0开始，则a[i]的地址= 首地址 + i*每个数据所占的长度；如果从1开始,则a[i]的地址= 首地址 + (i-1)*每个数据所占的长度
数组中变量的类型 ,就是声明数组时定义的类型.
java中声明数组是不能指定长度;数组创建后,长度不可变化.
java中数组不能越界,否则编译器会报数组越界错误.(ArrayIndexOutOfBoundsException)
数组存储在Java堆的连续内存空间，所以如果你创建一个大的索引，你可以有足够的堆空间直到抛出OutofmemoryError，因为请求的内存大小在连续的内存空间不可用。
数组创建后,每个元素都会自动初始化

类型	byet	short	int	long	float	double	char	booble	引用类型
默认值	0	0	0	0	0.0f	0.0d	\u0000	false	null

一维数组

定义
type[] arrayName; 或者 type arrayName[];
例如: int[] intArray; double doubleArray[];
初始化
- 静态初始化
  int[] intArray = {1,2,3,4};
  String stringArray[] = {"hello","world"};
  char[] charArray = new char[]{'a','b','c'};
- 动态初始化
  - 简单类型的数组
    int[] intArray;
    intArray = new int[5];
  - 复合类型的数组

String[] stringArray = new String[3];
stringArray[0]= new String("How");
stringArray[1]= new String("are");
stringArray[2]= new String("you");

3.数组元素的引用
数组元素的引用方式为：
　　　　　arrayName[index]

　　index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度
　　
代码举例
1.数组对象的创建
数组名 = new 数组元素类型[数组元素个数]
例如:

    public class TestArray{
        public static void main(String args[]){
            int[] arr;
            arr = new int[5];
            for(int i=0;i<5;i++){
                arr[i] = i;
                System.out.println(arr[i]);
            }
        }
    }

元素为引用类型的数据（注意：元素为引用数据类型的数组中的每一个元素都需要实例化）

public class TestArray{
    public static void main(String args[]){
        Student[] student;
        student = new student[3];
        for(int i=0; i<3; i++){
            student[i] = new Student("李四",89,9527);
            System.out.println("姓名:"
            +student[i].name
            +"  分数:"+student[i].score
            +"  学号:"+student[i].ID);
       }
   }
}
class Student{
    int name,score,ID;
    public Student(String name,
                            int score,
                            int ID){
        this.name = name;
        this.score = score;
        this.ID = ID;
    }
}

2.数组初始化：
1. 动态初始化：
数组定义与为数组元素分配空间和赋值的操作分开进行，
例如：

    public class TestArray{
        public static void main(String args[]){
            int[] arr = new int[3];
            arr[0] = 1 ;
            arr[1] = 2 ;
            arr[2] = 3 ;

            Student[] student = new Student[3];
            student[0] = new Student("张三",87,0528);
            student[1] = new Student("李四",76,0529);
            student[2] = new Student("赵六",91,0530);
        }
    }

    class Student{
        int name,score,ID;
        public Student(String name,int score,int ID){
            this.name = name;
            this.score = score;
            this.ID = ID;
        }
    }

静态初始化
在定义数组的同时就为数组元素分配空间并赋值，
例如：

public class TestArray{
    public static void main(String args[]){
        int[] arr = {1,2,3}


        Student[] student = {new Student("张三",87,0528),
                            new Student("李四",76,0529),
                            new Student("赵六",91,0530)};
    }
}
class Student{
    int name,score,ID;
    public Student(String name,int score,int ID){
        this.name = name;
        this.score = score;
        this.ID = ID;
    }
}

注意:
- int[] a ; 等价于 int a[]; –>定义一个int类型数组的引用a;
- int[] a = new int[5]; –>定义一个int类型引用并且分配空间,但是元素没有初始化,系统根据数组类型自动初始化
- int[] a = {1,2,2,3,4}; 等价于 int[] a = new int[]{1,2,2,3,4}–> 定义并初始化;
- 每个数组都有一个静态的属性,length,它是这个数组的长度;它是一个成员属性,没有加(),同String求字符串长度的length()方法有区别

字符串数组

String[] s = {"ss","bb","cc","rr"};
for(int i = 0 ; i < s.length ; i++){
    System.out.println(s[i]);
}

字符串

    String s = "aabbccdd";
    int length = s.length();

主方法中的字符串数组
public static void main(String[] args){}
我们每个类中的主函数也有一个数组，名叫args.
那么这个数组时干嘛用的呢？
这个数组就好比，我们在命令行中注入 ipconfig -all 中的all. 我们可以在输入
java 类名 23,12,aa,bbb 这个跟几个参数。然后可以在代码中输出来看到

class ClassName {
    public static void main(String[] args) {
        for(int i = 0 ; i < args.length;i ++){
            System.out.println(args[i]);
        }
    }
}

运行的时候用命名 java ClassName 1,2,3,4,5,就会在控制台输出 1,2,3,4,5
这句命令的意思是: args[0] = “1,2,3,4,5”; args.length的值为1
如果我们输入 java ClassName 1 2 3 4 5;
这句命令的意思是:args[0] = “1”;
args[1] = “2”;
……
args.length 的值为5.

举一个args[]参数和基础类型包装类一起使用的例子，用来计算+-x/：

public class ClassName{
    public static void main(String args[]){
        if(args.length<3){//必须要输入3个字符,中间字符是运算符
        //其他2个字符是要运算的值
            System.out.println("error~~~");
            System.exit(0);
        }
        //把字符串转换为double类型
        double  b1 = Double.parseDouble(args[0]);
        double  b2 = Double.parseDouble(args[2]);
        double  b = 0;
        if(args[1].equals("+")){
            b = b1 + b2;
        }else if(args[1].equals("-")){
            b = b1-b2;
        }else if(args[1].equals("x")){
            b = b1*b2;
        }else if(args[1].equals("/")){
            b = b1/b2;
        }else{
            System.out.println("error operation!!!");
        }
        System.out.println(b);
    }
}

下面举一个用ars输入10个数，并且用选择排序，从小到大排序的示例：

public class TestSortInt{
    public static void main(String args[]){
        int[] a = new int[args.length];
        for(int i=0; i<args.length; i++){
            a[i] = Integer.parseInt(args[i]);
        }
        int k,temp;
        for(int i=0; i<a.length; i++){
            k = i;
            for(int j=i+1; j<a.length; j++){
                if(a[k]>a[j]){
                    k=j;//k存储的是最小值的下标
                 }
            }
            if(k!=i){
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
        for(int i=0; i<a.length; i++){
            System.out.print(a[i] + " ");
        }
    }
}

下面我们用数组里面装一个日期类型做排序的示例，用了冒泡排序。

public class TestDateSort{
    public static void main(String args[]){
        Date[] date = new Date[5];
        date[0] = new Date(2006,5,4);
        date[1] = new Date(2006,7,4);
        date[2] = new Date(2008,5,4);
        date[3] = new Date(2004,5,9);
        date[4] = new Date(2006,5,4);

        bubbleSort(date);

        for(int i=0; i < date.length; i++){
            System.out.println(date[i]);
        }
    }
    public static Date[] bubbleSort(Date[] a){
        int len = a.length;
        for(int i=len; i>=1; i--){
            for(int j=0; j<i-1; j++){
                if(a[j].compare(a[j+1])>0){
                    Date temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }
}
class Date{
    private int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int compare(Date date){
        return year>date.year?1
               :year<date.year?-1
               :month>date.month?1
               :month<date.month?-1
               :day>date.day?1
               :day<date.day?-1
               :0;
    }
    public String toString(){
        return "year,month,day ---- " +year+" - "+month+" - "+day;
    }
}

下面我们用数组做一个数三退一的游戏，就是说，好多人围城一圈，数1,2,3三个数，数到3的人退出，剩余的人继续重新从1开始数数，知道剩下最后一个人，我们用数组求最后一个人是谁？

public class Count3Quit{
    public static void main(String args[]){
        boolean[] arr = new boolean[500];
        for(int i=0; i<arr.length; i++){
            arr[i] = true;
        }

        int leftCount = arr.length;
        int count = 0;
        int index = 0;
        while(leftCount > 1){
            if(arr[index] == true){
                count++;
                if(count == 3){
                    count = 0;
                    arr[index] = false;
                    leftCount --;
                }
            }
            index ++;
            if(index == arr.length){
                index=0;
            }
        }

        for(int i=0; i<arr.length; i++){
            if(arr[i]==true){
                System.out.println(i);
            }
        }
    }    
}

有了数组之后，我们可以设计各种各样的排序算法。然后在排好序的时候，我们又可以设计各种各样的查找算法，接下来，我们用数组实现一个简单的二分法查找算法

public class TestSearch{
    public static void main(String args[]){
        int[] a = {12,23,41,53,24,57,32,52,98,43,19,73};
        int postion = binarySearch(a,57);
        System.out.println(postion);
    }
    public static int binarySearch(int[] a, int searchNum){

        if(a.length==0)return -1;

        int startFlag = 0;
        int endFlag = a.length-1;
        int m = (startFlag+endFlag)/2;
        while(startFlag<=endFlag){
            if(a[m] == searchNum){
                return m;
            }else if(a[m]<searchNum){
                startFlag = m+1;
            }else if(a[m]>searchNum){
                startFlag = m+1;
            }
            m = (startFlag+endFlag)/2;
        }
        return -1;
    }
}

多维数组

1．二维数组的定义
　　type arrayName[ ][ ]；
　　type [ ][ ]arrayName;

2．二维数组的初始化
　　◇ 静态初始化
　　int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
　　Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

　　◇ 动态初始化
　　1) 直接为每一维分配空间，格式如下：
　　arrayName = new type[arrayLength1][arrayLength2];
　　int a[ ][ ] = new int[2][3]；

　　2) 从最高维开始，分别为每一维分配空间：
　　arrayName = new type[arrayLength1][ ];
　　arrayName[0] = new type[arrayLength20];
　　arrayName[1] = new type[arrayLength21];
　　…
　　arrayName[arrayLength1-1] = new type[arrayLength2n];

　　3) 例：
　　二维简单数据类型数组的动态初始化如下,
　　int a[ ][ ] = new int[2][ ]；
　　a[0] = new int[3];
　　a[1] = new int[5];

　　对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
　　而且，必须为每个数组元素单独分配空间。

　　例如：
　　String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//为最高维分配引用空间
　　s[1]= new String[2]; //为最高维分配引用空间
　　s[0][0]= new String(“Good”);// 为每个数组元素单独分配空间
　　s[0][1]= new String(“Luck”);// 为每个数组元素单独分配空间
　　s[1][0]= new String(“to”);// 为每个数组元素单独分配空间
　　s[1][1]= new String(“You”);// 为每个数组元素单独分配空间

　3．二维数组元素的引用
　　
　　对二维数组中的每个元素，引用方式为：arrayName[index1][index2]
　　例如： num[1][0];
　　两个矩阵交换:

class twoArrayTest {
    public static void main(String[] args) {
        int arry[][] = {{1,2,3},{4,5,6},{7,8,9}};
        for(int i = 0 ; i <= 2 ; i++){
            for(int j = 0 ; j <= 2 ; j++){
                System.out.print(arry[i][j]+" ");
            }
            System.out.println();
        }
        for(int i = 0 ; i <= 2 ; i++){
            for(int j =  i; j <= 2 ; j++){
                int temp = arry[i][j];
                arry[i][j] = arry[j][i];
                arry[j][i] = temp;
            }
        }
        System.out.println("转换后");
        for(int i = 0 ; i <= 2 ; i++){
            for(int j = 0 ; j <= 2 ; j++){
                System.out.print(arry[i][j]+" ");
            }
            System.out.println();
        }
    }
}

2.位运算

按位与 & (AND)

都为1才为1,否则为0

 public class Demo1 {
    public static void main(String[] args) {
        int a = 4 ;// 00000000 00000000 00000000 00000100 
        int b = 7 ;// 00000000 00000000 00000000 00000111
        int c = a & b ; //                       00000100
        System.out.println(c);
    }
}

应用:
1. 迅速清零
int a = 4 ;
a = a & 0; //结果为0
2. 保留指定位数据
int a = 409; // 00000000 00000000 00000001 10011001
int b = 255; // 00000000 00000000 00000000 11111111
//取a的低8位
a = a & b ; // 00000000 00000000 00000000 10011001

判断奇偶性
int a = 整数 ;
int b = a & 1;
如果b = 1,则a是奇数;
如果b = 0,则a是偶数;
解释:把一个整数用二进制表示,如果最低位是1的话,则这个整数肯定是奇数;
这个整数跟1按位与的时候,即最低位跟二进制001按位与,如果结果为1,则这个整
数对应二进制位的最低位必定也为1,所以这个整数必定是奇数.

按位或 | (OR)

有一个为1,结果就为1;全为0,结果才为0

public class Demo2 {
        public static void main(String[] args) {
            int a = 9 ;// 00000000 00000000 00000000 00001001 
            int b = 5 ;// 00000000 00000000 00000000 00000101
            int c = a | b ; //                       00001101
            System.out.println(c);
    }
}

应用:
1.设定数据的指定位置
将Demo2中 a 的低8位全部设置为1
a = a | 0xFF;//0xFF–>255–>10000000

按位异或 ^ (XOR)

当对应位互斥的时候,结果才为1,否则为0

public class Demo3 {
        public static void main(String[] args) {
            int a = 10;// 00000000 00000000 00000000 00001010 
            int b = 7 ;// 00000000 00000000 00000000 00000111
            int c = a ^ b ; //                       00001101
            System.out.println(c);
    }
}

性质:
1. 交换律
2. 结合律
3. 对于任何数x，都有x^x=0，x^0=x
4. 自反性 A XOR B XOR B = A xor 0 = A
应用:
1. 定位反转
  a = a ^ x; //(x是一个跟a对应的二进制有相同位数的全为一的二进制数)
2. 数值交换
  a = a ^ b;
  b = b ^ a;
  a = a ^ b;
练习:
1-1000放在含有1001个元素的数组中，只有唯一的一个元素值重复，其它均只出现一次。每个数组元素只能访问一次，设计一个算法，将它找出来；不用辅助存储空
间，能否设计一个算法实现？
- 算法一:
  把所有数加起来再减去1+2+..+1000的和,剩下的就是那个数
  缺点是如果数据足够大,会超过数据存储范围
```
public static int methode (int[] a) {
    int arraySum = 0 ;
    int sum = 0;
    for(int i = 0 ; i < a.length ; i ++){
        arraySum += a[i];
    }
    for(int j = 1 ; j <= 1000 ; j ++){
        sum += j;
    }
    return arraySum - sum;
}
```
- 算法二:
  将所有的数全部异或，得到的结果与1^2^3^…^1000的结果进行异或，得到的结果就是重复数
  证明:由 ^ 操作符的4个性质,假设多出的那个数为n,
  则1^2^…^n^n^…^1000 = (1^2^..^1000)^n^n= a (这个结果里面没有n)
  然后把这个结果同从1异或到1000的结果异或,
  假设 b = 1^2^3^…^1000(有n)–> b = a ^ n
  则 a ^ b = a ^ (a ^ n)就等于n (对于任何数x，都有x^x=0，x^0=x)

    public static int method(int[] a) {
        int resultA = 0;
        int resultB = 0;
        for(int i = 0 ; i < a.length ; i++){
            resultA ^= a[i];
        }
        for(int j = 1 ; j <= 1000 ; j++){
            resultB ^= j;
        }
        return resultA ^ resultB;
    }

取反 ~

~(00001011)

左移 << 右移 >>

左移 n位,就是乘以2的n次方
右移 n位,就是除以2的n次方

public class Demo4 {
        public static void main(String[] args) {
            int a = 10;// 00000000 00000000 00000000 00001010 
            int c = a << 4 ; //                      11010000
            System.out.println(c);
    }
}

收录于