知不知

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();
    }
}

知不知

知不知 是一个代码爱好者的技术知识分享部落格。