JavaSE之路-02

1、运算符

算术 自增自减 逻辑 比较 赋值 位 移位 三元

问题： 区分 &&(短路与) 与 &(不会短路)

int  a =5,b=3;
boolean b1 = b > a && a++ > 5;  //短路与
System.out.println(b1);  false
System.out.println(a);   5

boolean b2 = b>a || a++ > 5；
System.out.println(b2) false
System.out.println(a);  6 

boolean b3 = b>a  &  a++ > 5；  
System.out.println(b3);//  ???  false  &不会短路
System.out.println(a);   7
// & 即是逻辑运算符，还是位运算符。 || 和 | 同理
System.out.println(5 & 3); //101 & 011  001 1
System.out.println(5 | 3);// 7
System.out.println(5 ^ 3); // 6  

问题：boolean b4 = 5 & 2 ==0；

关键：运算优先级

错误， == 的优先级 大于 &

5 & false 错误 ，该加运算符加运算符

2、流程控制

锻炼程序逻辑

3、数组

三种定义方式

    public static void main(String[] args) {
        //请定义一个长度为5的整型数组，写出三种方式，内容不
        int[] a = new int[5];
        int[] a1 = new int[]{1,2,3,4,5};
        int[] a2 = {5,6,7,8,9};
        int  x  = 0x4554617c;
        System.out.println(a);
//        [I@4554617c  I表示类型。@表示在 后面的数字可以理解为地址，
//        实际为hashcode值 16进制
//    a变量中存储的是地址，Java中叫引用
        System.out.println(a.hashCode());
        System.out.println(x);
   

数据类型

基础数据类型变量中存储的是变量本身，引用数据类型变量中存储的是变量的引用(地址)，指向真正存储数据的空间。

为什么这么设计？直接存储不行吗?

主要关键点：内存问题，栈很小，堆很大

因为内存分为栈和堆，栈的特点是少，快，堆的特点是多，慢。

直接存储是存在栈中，栈的空间会很快用完，会发生错误，而采用引用，可以有效利用堆。实际上这种结合的思想和cache 和缓存结合的思想一致。

//这种设计是基于堆，栈空间的特征

//默认值 ，有空间即有值 0/0.0 false null

数组打印

//1.格式化打印
System.out.println(Arrays.toString(a1));//Arrays ,数组操作的帮助类，toString()格式化打印
    }
//for 循环
//增强 for 循环 (foreach)

排序、扩容、拷贝

课堂练习

扩容的思路：重新定义数组，拷贝原来的值，新的引用赋值给原变量

public class A2 {
    public static void main(String[] args) {
        //从控制台循环获取用户输入的成绩(int),当用户输入-1时，停止录入
        //然后，打印出从小到大排序后的结果。
        Scanner s = new Scanner(System.in);
        int [] a = new int[5];
        System.out.println("请循环输入成绩：");
        int count = 0;
        while (true){
            int c = s.nextInt();
            if(c== -1){
                break;
            }
            //判断+扩容
            //手动
//            if(count == a.length){
//                int [] a1 = new int[2 * a.length ];
//                for (int i = 0; i < a.length ; i++) {
//                    a1[i] = a[i];
//                }
//                a = a1;
//
//            }
            //调用API  扩容
            if(count == a.length){
            a =  Arrays.copyOf(a,a.length*2 );}

            a[count++] = c;

        }
        //格式化输出
        System.out.println(Arrays.toString(a));

        //排序
        //默认从小到大排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //把0去掉 , 0不好看
        int[] a3 = new int[count];
        //拷贝到新的数组
        System.arraycopy(a,0,a3,0,count); //省去了手动for
        System.out.println(Arrays.toString(a3));
        //从大到小排序
        //第二个参数是一个比较级
        //面向对象会讲，匿名接口类，泛型
        Integer[] a4 = new Integer[count];
        for (int i = 0; i < count ; i++) {
            a4[i] = a3[i];
        }

        //因为比较级的参数是Integer,所以数组类型要转成Integer
        Arrays.sort(a4, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(a4));
        //另一种写法，Lambda表达式（函数式编程）
        Arrays.sort(a4,(o1,o2)-> o2 -o1);

        System.out.println(Arrays.toString(a4));

}
}

总结：排序 ，Arrays.sort()

扩容：Arrays.copyof()

拷贝：System.arraycopy()

4、函数

JavaSE之路-02

原文：https://www.cnblogs.com/moshanghuai/p/13584883.html