Java-Java中的基本数据类型

主要内容有:Java编译、环境配置、内存模型、基本数据类型、原码、反码、补码、排队系统、数组二分查找。

基本概念

编译执行java文件

C:\~>javac -d . ch01/HelloWorld.java
C:\~>java ch01.HelloWorld

Hello World!

C:\~>java ch01/HelloWorld    这样也可以

Hello World!

生成Javadoc:标准的注释文档(html)

C:\~>javadoc -d doc ch02
C:\~>javadoc -author -version -d doc ch02
window下默认字符编码:GBK
linux下的默认字符编码:utf-8
生成javadoc:标准的注释文档(html)
javadoc -d doc ch02; (不显示单行注释和多行注释。不显示)
win下默认的字符编码是:gbk
linux下默认编码是:utf-8
-d :生成的文档放在哪里
-author:生成作者
-version:生成版本
java api 用javadoc 来生成的

java内存模型

1.堆区(heap):放置新生成的对象
2.栈区(stack):存在我们程序运行过程中的变量
变量:内存节点的值可以被重写
常量:内存节点的值不可以被重写

3.方法区:方法的信息,程序运行过程中类的信息
4.常量区 静态存储区:存放程序运行过程中的常量

程序中随着数据的增加,堆地址不断地向高地址增加,栈地址不断地向低地址减小
String a = "abc";//常量区
String b = new String ("abc");//堆区
String c = new String ("abc");
String d = "abc";
a==b 错 b==c 错 (两个不同的对象) a==d 对
==:用来比较地址(对于对象来说),比较值(对于基本类型)

java运行环境的搭建

JDK:JAVA DEVELOPMENT TOOLKIT //java 开发
JRE:JAVA RUNTIOME ENVIRONMENT //java 运行环境
jdk:编译源代码 同时运行class
jre:运行class文件

配置环境变量

Unix : PATH:命令搜索路径
cat .bashrc
oracle_home :说明了oracle的安装路径
java_home
env 查看所有环境变量
将java_home的bin路径添加到path里面
unix 用 ':' 分隔路径
path=$path:$java_home/bin

配置:
source.bashrc:环境变量立刻生效。

java中的类型

java是强类型语言,在定义变量的时候必须声明变量的类型
弱类型:声明变量不需要指定的类型语言
html css js 对于js来说是弱类型语言
在js里面声明任何一个变量都用变量一个声明 var
强类型的好处:在编译期进行类型检查,减少程序出错的概率。
强类型的坏处:灵活性差

1.基本类型
八种:
表示整数的: 4个 int(32位),long(64位),short(16位),byte(8位)
表示小数的(浮点数): 2个 float,double
表示布尔类型的:boolean (true|false) 表示判断条件
便是字符类型:char

2.引用类型
object 类:任何自定义的类都继承object
表示字符串的:多个字符
String 用来声明字符串 (java.long.String)

引用类型:类类型
类:对现实实体的抽象
包含属性和方法(函数)
属性:描述现实的实体
Person:name gender age
方法:操纵属性

java中的基本数据类型

//java中的基本数据类型 .
public class PrimitiveTypeTest {
    //private static PrimitiveTypeTest primitiveType;
    private int i1;

    public int getI1() {
        return i1;
    }

    public Integer getI2()//调用它是因为自动拆箱、装箱,所有不报错
    {
        return i1;
    }

    public int obtainInt() {
        return i1;
    }

    /**
     * public void initVal()
     * {
     * System.out.println("-----------------initVal  int i1:"+i1);
     * primitiveType=new PrimitiveTypeTest();
     * }
     */

    private Integer i2;

    public Integer getInteger() {
        return i2;
    }

    private byte b1;

    public Byte getB1() {
        return b1;
    }

    boolean bool;

    public Boolean getBoolean() {
        return bool;
    }

    short srt;

    public short getShort() {
        return srt;
    }

    long lg;

    public long getLong() {
        return lg;
    }

    float flt;

    public float getFloat() {
        return flt;
    }

    double dble;

    public double getDouble() {
        return dble;
    }

    char cha;

    public char getChar() {
        return cha;
    }

    public static void main(String[] args) {
        PrimitiveTypeTest primitiveType = new PrimitiveTypeTest();
        // byte
        System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE);
        System.out.println("包装类:java.lang.Byte");
        System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        //Byte b1=new Byte("0");
        //System.out.println("Byte默认赋值为:"+b1);
        System.out.println("byte默认赋值为:" + primitiveType.getB1());
        System.out.println("-----------------------------------");

        //-------------------short-----------------------
        System.out.println("基本类型:short 二进制位数:" + Short.SIZE);
        System.out.println("包装类:java.lang.Short");
        System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println("short默认赋值为:" + primitiveType.getShort());
        //Short s1;
        //short s2;
        //System.out.println("Short默认赋值为:"+(s1==0));
        //System.out.println("short默认赋值为:"+s2);
        System.out.println("-----------------------------------");
        //-------------------------int-------------------------
        System.out.println("基本类型:int 二进制位数:" + Integer.SIZE);
        System.out.println("包装类:java.lang.Integer");
        System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        //Integer i1;
        //System.out.println("Integer默认赋值为:"+(i1==0));
        //只有通过new 了之后才能取到默认值
        System.out.println("int默认赋值为:" + primitiveType.getI1());
        System.out.println("int默认赋值为:" + primitiveType.getI2());
        System.out.println("int默认赋值为:" + primitiveType.obtainInt());
        System.out.println("Integer默认赋值为:" + primitiveType.getInteger());
        //System.out.println("int默认赋值为:"+i1);
        System.out.println("-----------------------------------");

        //--------------------------long-------------------
        System.out.println("基本类型:long 二进制位数:" + Long.SIZE);
        System.out.println("包装类:java.lang.Long");
        System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println("long默认赋值为:" + primitiveType.getLong());
        //Long l1;
        //long l2;
        //System.out.println("Long默认赋值为:"+(l1==0));
        //System.out.println("long默认赋值为:"+l2);
        System.out.println("-----------------------------------");

        //------------------------float---------------------------
        System.out.println("基本类型:float 二进制位数:" + Float.SIZE);
        System.out.println("包装类:java.lang.Float");
        System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println("float默认赋值为:" + primitiveType.getFloat());
        //Float f1;
        //float f2;
        //System.out.println("Float默认赋值为:"+(f1==0));
        System.out.println("-----------------------------------");

        //-------------------------double------------------------
        System.out.println("基本类型:double 二进制位数:" + Double.SIZE);
        System.out.println("包装类:java.lang.Double");
        System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println("double默认赋值为:" + primitiveType.getDouble());
        //Double d1;
        //double d2;
        //System.out.println("Double默认赋值为:"+(d1==0));
        //System.out.println("double默认赋值为:"+d2);
        System.out.println("-----------------------------------");

        //---------------------char----------------------
        System.out.println("基本类型:char 二进制位数:" + Character.SIZE);
        System.out.println("包装类:java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值:Character.MIN_VALUE="
                + (int) Character.MIN_VALUE);
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值:Character.MAX_VALUE="
                + (int) Character.MAX_VALUE);
        System.out.println("char默认赋值为:" + primitiveType.getChar());
        //Character c1;
        //char c2;
        //System.out.println("Character默认赋值为:"+(c1=='\0'));
        //System.out.println("char默认赋值为:"+c2);
        System.out.println("-----------------------------------");

        //-----------------------Boolean---------------------
        System.out.println("包装类:java.lang.Boolean");
        Boolean b = new Boolean(false);
        System.out.println("boolean默认赋值为:" + primitiveType.getBoolean());
        System.out.println("-----------------------------------");
    }
}

修饰符及属性的说明

//类没有protected和private修饰符
//被public 修饰的类,可以被其它包中的类访问
public class TestA
{
    //private 级别的属性和方法
    private int a=101;
    private void printA()
    {
        System.out.println("printA方法:"+this.a);
    }

    //默认级别的属性和方法
    int b=102;
    void printB()
    {
        System.out.println("printB方法:"+this.b);
    }

    //protected级别的属性和方法
    protected int c=103;
    protected void printC()
    {
        System.out.println("printC方法:"+this.c);
    }

    //public级别的属性和方法
    public int d=104;
    public void printD()
    {
        System.out.println("printD方法:"+this.d);
    }
}

//没有被public 修饰的类不能被其它包中的类访问
class TestB
{
    //private 级别的属性和方法
    private int a=101;
    private void printA()
    {
        System.out.println("printA方法:"+this.a);
    }

    //默认级别的属性和方法
    int b=102;
    void printB()
    {
        System.out.println("printB方法:"+this.b);
    }

    //protected级别的属性和方法
    protected int c=103;
    protected void printC()
    {
        System.out.println("printC方法:"+this.c);
    }

    //public级别的属性和方法
    public int d=104;
    public void printD()
    {
        System.out.println("printD方法:"+this.d);
    }
}

//被final修饰的类不能被继承
final class TestC
{
    //private 级别的属性和方法
    private int a=101;
    private void printA()
    {
        System.out.println("printA方法:"+this.a);
    }

    //默认级别的属性和方法
    int b=102;
    void printB()
    {
        System.out.println("printB方法:"+this.b);
    }

    //protected级别的属性和方法
    protected int c=103;
    protected void printC()
    {
        System.out.println("printC方法:"+this.c);
    }

    //public级别的属性和方法
    public int d=104;
    public void printD()
    {
        System.out.println("printD方法:"+this.d);
    }
}

二进制:原码、反码、补码

对于有符号的数而言(Java中全都是有符号的数)

二进制的最高位是符号位:0表示正数,1表示负数
正数的原码,反码,补码都一样(直接为此数二进制数表示)
负数的原码,符号为1,其余各位为此数的二进制表示
负数的反码=它的原码符号不变,其它位取反(1à0,0à1)
负数的补码=它的反码+1
0的反码、补码都是0
java中没有无符号数,换言之,java中的数都是有符号的
在计算机运算的时候,都是以补码的方式运算的
 
例:1-2=1+(-2)
计算[1+(-2)]在计算机中是以补码的方式运算的,首先计算:
[1的补码]+[(-2)的补码]
[1的补码]= 【0000000000000000000000000000001】
[(-2)的原码]=【1000000000000000000000000000010】
[(-2)的反码]=【1111111111111111111111111111101】
[(-2)的补码]=【1111111111111111111111111111110】
[1+(-2)的补码]=[1的补码]+[(-2)的补码]=【1111111111111111111111111111111】

然后,将 [1的补码]+[(-2)的补码]=[(1+(-2))的补码] à [1+(-2)的原码]:
[1+(-2)的补码 – 1]=【1111111111111111111111111111110】
[(1-2)原码]= [{1+(-2)的补码 – 1}符号位不变,其它各位取反]=【1000000000000000000000000000001】
即:[(1-2)原码]=【1000000000000000000000000000001】=-1

位运算符:
按位与&:两位全为1,结果为1
按位或|:两位有一个为1,结果为1
按位异或^:两位一个为0,一个为1,结果为1
按位取反~:0 à 1,1 à 0

例:
~-5=4 (在计算机中,取反运算符是给一个数补码取反)
[(-5)的原码]= 【1000000000000000000000000000101】
[(-5)的反码]= 【1111111111111111111111111111010】
[(-5)的补码]= 【1111111111111111111111111111011】
[{(-5)的补码}按位取反后]=【0000000000000000000000000000100】=4

Java中的数组

数组:存放相同类型数据的连续的内存空间
相同类型 连续的内存空间
地址号连续
存储数据(基本类型 对象类型)
集合:collection,List很多子类的实现都是基于数组
链表:内存地址不连续
数组和链表的比较:

1.内存开辟:链表开辟内存更容易
2.对元素的访问:对于数组来说,检索效率高,插入和删除效率低,可能涉及到数组的重新开辟和拷贝

1.声明数组:
制定数组的类型 [] 数组的引用名 = new 数组的类型[数组的大小] --> 一维数组
int [] array = new int[30];
Person array [] = new Person[30];

2.初始化:
a.在声明的时候进行初始化
int [] array= new int []{1,2,3,4,5};
Person array [] = new Person [] {new Person(), new Person()};

b.对数组内的单个元素进行初始化
数组的索引:用来对数组内的元素进行访问。从0开始
array[index]:访问数组内的特定元素
array[4]->5//访问
array[4]=10;//修改
c.可以通过循环进行初始化

for(int i=0;i<array.length;i++){
    array[i]=i+1;
}

二维数组
二维数组:通过两个索引确定一个元素
数据库中的表的行和列

声明:
int [][] array=new int [10][10];
array[i][j];

锯齿数组
锯齿数组:指定有多少行,但是不指定列数
int [][] array=new int [10][];
array[0]=new int [10];
array[1]=new int [5];
array[2]=new int [8];

减少内存使用 在程序运行期间确定列数
tdd:test driven development 测试驱动开发 先写测试代码,再写功能代码

数组实例项目

银行排号系统

需求描述:描述程序的基本功能.
需求分析:1/3时间 收集客户需要的功能并进行抽象——》生成面向对象里面的类
银行排号系统:取号机:先到显得
数据结构:队列:先进先出 FIFO
叫号机:

基于数组实现

class Queue{
    public int [] array;//存放号码
    public int size;//存放当前数组里最大的元素的个数
    public int maxSize;//说明数组的容量
    public int value;//存放号码值
    public void add();//添加
    public void remove();//叫号
    public void testArray()//查看数组容量是否够用,动态开辟 数组的拷贝

    //取号:始终在队尾插入
    //叫好:始终在队首删除
    //数组的搬移
}

ch04/Queue.java* ch04/QueueTest.java

/**
 *排号系统
 */
public class Queue {
    public int[] array;//存放数据的数组
    public int size;//记录当前队列下一个元素的index
    public int maxSize;//记录当前队列的最大内容
    public int value;//下一个号码

    /**
     *初始化队列
     */
    public Queue() {
        this.array = new int[20];
        this.maxSize = 20;
    }

    public Queue(int maxSize) {
        this.maxSize = maxSize;
        this.array = new int[maxSize];
    }

    /**
     *取号
     */
    public void add() {
        testArray();
        array[size] = value + 1;
        size++;
        value++;
    }

    /**
     *叫号
     */
    public void remove() {
        if (size == 0) {
            return;
        }
        for (int i = 1; i < size; i++) {
            array[i - 1] = array[i];
        }
        array[size - 1] = null;
        size--;
    }

    /**
     *查询数据 并动态开辟
     */
    public void testArray() {
        if (size >= this.maxSize) {
            int[] newArray = new int[this.maxSize + 20];
            System.arraycopy(this.array, 0, newArray, 0, size);
            this.array = newArray;
            this.maxSize += 20;
        }
    }

    /**
     *查看数组所有元素
     */
    public void print() {
        for (int i = 0; i < size; i++) {
            System.out.print(this.array[i] + "\t");
        }
        System.out.println();
    }
}

队列操作

public class QueueTest{
    public static void main(String args[]){
        Queue queue=new Queue();
        queue.add();
        queue.add();
        queue.print();
        queue.remove();
        queue.print();
        queue.remove();
        queue.print();
        for(int i=0;i<30;i++){
            queue.add();
        }
        queue.print();
        for(int j=0;j<20;j++){
            queue.remove();
        }
        queue.print();
    }
}

数组二分查找、排序、输出

import java.util.Arrays;
public class ArraysTest{
    public static void main(String args[]){
        int [] array = new int []{10,1,2,5,9,8,6,7,4,3};
        int index=Arrays.binarySearch(array,0,array.length,5);
        System.out.println("6`s index:"+index);
        Arrays.sort(array);//对整个数组进行排序
        print(array);
    }
    public static void print(int [] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();
    }
}

版权所有,转载请注明出处 luowei.github.io.