您的位置 首页 java

从零打造IT知识体系-Java基础-02基本数据类型与算法上

当前知识体系图谱

绿色:已学习内容。蓝色:本次学习内容

1 Java的数据类型

Java数据类型(type) 包括:基本类型(primitive types)和引用类型(reference types)

Java是一种强类型语言,必须为每个变量声明其类型。在Java中,一共有8种基本类型,其中4种整型,2种浮点类型,1种表示Unicode编码的字符单元的字符类型char,1种用于表示真假值得 boolean 类型。

1.1 基本类型(primitive types)

1.1.1 基本类型简介

基本类型 包括: boolean类型 数值类型 (numeric types)
数值类型(numeric types) 又分为 整型(integer types )和 浮点型( float ing-point type)
整型 有5种: byte、 short 、int、 long 、char (char本质上是一种特殊的int)。浮点类型有 float double

8种类型表示范围如下:

  • byte:8位,最大存储数据量是255,存放的数据范围是-128~127之间。
  • short:16位,最大存储数据量是65536,数据范围是-32768~32767之间。
  • int:32位,最大数据存储容量是2的32次方减1,数据范围是负的2的31次方到正的2的31次方减1。
  • long:64位,最大数据存储容量是2的64次方减1,数据范围为负的2的63次方到正的2的63次方减1。
  • float:32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。
  • double:64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加。
  • boolean:1位,只有true和 false 两个取值。
  • char:16位,存储Unicode码,用单引号赋值。

1.1.2 基本类型的封装器类

Java每个基本类型都对应着封装类

  • byte:Byte
  • short:Short
  • int:Integer
  • long:Long
  • float:Float
  • double:Double
  • boolean:Boolean
  • char:Character

1.1.3 基本类型与其封装类类型比较

  • 原始数据类型在传递参数时都是按值传递,封装类是对象,都是按引用传递
  • 封装类实际是对象的引用,当new一个封装类时,实际上是生成一个指针指向此对象;而基本类型则是直接存储数据值
  • Java基本类型存储在栈中
  • Integer的默认值是null,int的默认值是0,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,返回数据库字段值是null的话,实体类中用int类型接收的话会报错。int是基本数据类型,其声明的是变量,而null则是对象。所以建议用integer
  • Integer对于-128到127之间的数,会进行缓存,Integer i = 127时,会将127进行缓存,下次再写Integer j = 127时,就会直接从缓存中取,就不会new了
  • int 和 Integer在进行比较的时候,Integer会进行拆箱,转为int值与int进行比较。其它数值类型也是一样。
  • Integer与Integer比较的时候,由于直接赋值的时候会进行自动的装箱,那么这里就需要注意两个问题,一个是-128<= x<=127的整数,将会直接缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是从缓存中获取已经创建好的Integer对象。二:当大于这个范围的时候,直接new Integer来创建Integer对象。
  • new Integer(1) 和Integer a = 1不同,前者会创建对象,存储在堆中,而后者因为在-128到127的范围内,不会创建新的对象,而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer(128)创建对象,进行装箱
  • Java语言中,默认声明的小数是double类型的,因此对float类型的变量进行初始化时需要进行类型转换
  • 基本型封装类型调用equals(),但是参数是基本类型,这时候,先会进行自动装箱,基本型转换为其封装类型
  • 两个基本型的封装型进行equals()比较,首先equals()会比较类型,如果类型相同,则继续比较值,如果值也相同,返回true
  • 基本型和基本型封装型进行“==”运算符的比较,基本型封装型将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较。

1.1.4 数据类型转换

byte <(short=char)< int < long < float < double
如果从小转换到大,可以自动完成,而从大到小,必须强制转换。short和char两种相同类型也必须强制转换。

1.2 引用类型(reference types)

引用类型(reference types)包括类(class)、接口(interface)、数组(array)、空(null)

引用类型记住一点,传递参数时是引用传递,以后会继续学习。

2 Java基本算法(参考菜鸟教程)

Java 运算符 – 算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符Java 循环结构 – for, while 及 do…whileJava 条件语句 – if…elseJava switch case 语句

Java的语法主要包含运算符、循环结构、条件语句、分支选择switch语句。接下来我们通过代码一个一个认识这些语法。

2.1 Java运算符

2.1.1 算术运算符

算术运算符用在数学表达式中,它们的作用和在数学中的作用一样。

运算符:

  • 加法(+):
    相加运算符两侧的值:A + B
  • 减法(-):
    左操作数减去右操作数:A – B
  • 乘法(*):
    相乘操作符两侧的值:A * B
  • 除法(/):
    左操作数除以右操作数:A / B
  • 取余(%):
    左操作数除以右操作数的余数 :A % B
  • 自增(++):
    操作数的值增加1 :B++ 或 ++BB
  • 自增(–):
    操作数的值增加1 :B– 或 –BB

示例代码:

 public class ArithmeticOperation {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看 d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
    }
}  

运算结果:

 a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27  

2.1.2 关系运算符

关系运算符,用于2个操作数的比较,其结果要么为真,要么为假。

运算符:

  • 是否相等(==):
    检查如果两个操作数的值是否相等,如果相等则条件为真。
  • 是否不相等(!=):
    检查如果两个操作数的值是否相等,如果值不相等则条件为真。
  • 是否大于(>):
    检查左操作数的值是否大于右操作数的值,如果是那么条件为真。
  • 是否小于(<):
    检查左操作数的值是否小于右操作数的值,如果是那么条件为真。
  • 是否大于等于(>=):
    检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。
  • 是否小于等于(<=):
    检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。

示例代码:

 RelationalOperation {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b = " + (a == b) );
        System.out.println("a != b = " + (a != b) );
        System.out.println("a > b = " + (a > b) );
        System.out.println("a < b = " + (a < b) );
        System.out.println("b >= a = " + (b >= a) );
        System.out.println("b <= a = " + (b <= a) );
    }
}  

运算结果:

 a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false  

2.1.3 位运算符

Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
位运算符首先转化为二进制,再按照对应位进行位运算规则计算,由于直接操作位移,效率极高。

运算符:

  • 与(&):
    如果相对应位都是1,则结果为1,否则为0
  • 或(|):
    如果相对应位都是 0,则结果为 0,否则为 1
  • 异或(^):
    如果相对应位值相同,则结果为0,否则为1
  • 非(〜):
    按位取反运算符翻转操作数的每一位,即0变成1,1变成0。
  • 左移(<<):
    将运算符左边的对象向左移动运算符右边指定的位数(在低位补0)
  • “有符号”右移(>>):
    将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制,也就是说,如果值为正,则在高位补0,如果值为负,则在高位补1。
  • “无符号”右移(>>>):
    将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制,也就是说,无论值的正负,都在高位补0。

示例代码:

 public class BitOperation {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}  

运算结果:

 a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15  

2.1.4 逻辑运算符

顾名思义,进行2个操作数的逻辑上的判断。

运算符:

  • 与(&&):
    称为逻辑与运算符。而且仅当两个操作数都为真,条件才为真。
  • 或(||):
    称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。
  • 非(!):
    称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。

示例代码:

 public class LogicOperation {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a&&b));
        System.out.println("a || b = " + (a||b) );
        System.out.println("!(a && b) = " + !(a && b));
    }
}  

运算结果:

 a && b = false
a || b = true
!(a && b) = true  

2.1.5 赋值运算符

将操作数进行指定的运行后,进行赋值覆盖。

运算符:

  • 赋值(=):
    简单的赋值运算符,将右操作数的值赋给左侧操作数:C = A + B将把A + B得到的值赋给C
  • 加和赋值(+ =):
    加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数:C + = A等价于C = C + A
  • 减和赋值(- =):
    减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数:C – = A等价于C = C – A
  • 乘和赋值( =):
    乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数:C
    = A等价于C = C * A
  • 除和赋值(/ =):
    除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数:C / = A,C 与 A 同类型时等价于 C = C / A
  • 取模和赋值((%)=):
    取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数:C%= A等价于C = C%A
  • 左移位赋值(<< =):
    左移位赋值运算符:C << = 2等价于C = C << 2
  • 右移位赋值(>> =):
    右移位赋值运算符:C >> = 2等价于C = C >> 2
  • 按位与赋值(&=):
    按位与赋值运算符:C&= 2等价于C = C&2
  • 按位异或赋值(^ =):
    按位异或赋值操作符:C ^ = 2等价于C = C ^ 2
  • 按位或赋值(| =):
    按位或赋值操作符:C | = 2等价于C = C | 2

示例代码:

 public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}  

运算结果:

 c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10  

2.1.6 三目条件运算符

三目条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false

运算符:

  • 三目条件运算(?:):
    根据A的结果,若为真则返回B,若为假则返回C: A?B:C

示例代码:

 public class ConditionalOperator {
    public static void main(String[] args){
        int a , b;
        a = 10;
        // 如果 a 等于 1 成立,则设置 b 为 20,否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println( "Value of b is : " +  b );

        // 如果 a 等于 10 成立,则设置 b 为 20,否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println( "Value of b is : " + b );
    }
}  

运算结果

 Value of b is : 30
Value of b is : 20  

2.1.7 instanceof运算符

该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。
( Object reference variable ) instanceof (class/interface type)

运算符:

  • 类型判断运算(instanceof):
    判断A类型是否是B类型、B类型的实现、B类型的子类。

示例代码:

 public class InstanceofOperation {

    public static void main(String[] args){
        String name = "James";
        boolean result1 = name instanceof String; // 由于 name 是 String 类型,所以返回真
        System.out.println( result1);

        Vehicle a = new Car();
        boolean result2 =  a instanceof Car;
        System.out.println( result2);

        Bar bar = new Bar();
        boolean result3 =  bar instanceof Foo;
        System.out.println( result3);
    }
}

interface Foo{}

class Bar implements Foo{

}

class Vehicle {}

class Car extends Vehicle {

}  

运算结果:

 true
true
true  

2.2 Java运算符优先级

当多个运算符出现在一个表达式中,谁先谁后呢?这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中,运算符优先级不同会导致最后得出的结果差别甚大。

优先级记忆方法:单目乘除为关系,逻辑三目后赋值。

实际开发中,应以括号辅助优先级管理。

参考文档:
菜鸟教程:
java运算符优先级记忆口诀

文章来源:智云一二三科技

文章标题:从零打造IT知识体系-Java基础-02基本数据类型与算法上

文章地址:https://www.zhihuclub.com/194220.shtml

关于作者: 智云科技

热门文章

发表回复

您的电子邮箱地址不会被公开。

网站地图