——年金波老师上课笔记
编译执行java文件
F:\杰普培训笔记>javac -d . ch01/HelloWorld.java
F:\杰普培训笔记>java ch01.HelloWorld
Hello World!
F:\杰普培训笔记>java ch01/HelloWorld 这样也可以
Hello World!
生成Javadoc:标准的注释文档(html)
F:\杰普培训笔记\core_java>javadoc -d doc ch02
F:\杰普培训笔记\core_java>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)
ch02/PrimitiveTest.java
引用类型:类类型
类:对现实实体的抽象
包含属性和方法(函数)
属性:描述现实的实体
Person:name gender age
方法:操纵属性
java中的基本数据类型
例1:
package ch02;
public class PrimitiveTest
{
public static void main(String []args)
{
int ivar1=0x11; //16进制
int ivar2=011; //8进制
int ivar3=17; //10进制
float fvar1=12.5e5f;
double dvar1=0.1234d;
System.out.println("fvar1="+fvar1);
System.out.println("dvar1="+dvar1);
boolean flag=true;
System.out.println("boolean:"+flag);
System.out.println("ivar1="+ivar1);
System.out.println("ivar2="+ivar2);
System.out.println("ivar3="+ivar3);
char gender='F';
char test='\u0065'; //unicode码
System.out.println("gender:"+gender);
System.out.println("test:"+test
例2:
//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("-----------------------------------");
}
}
二进制:原码、反码、补码
对于有符号的数而言(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:
package ch04;
public class SumTest{
public static void main (String args[]){
int [] array = new int[100];
int sum=0;
for (int i=0;i<array.length;i++){
array[i]=i+1;
sum=sum+array[i];
System.out.print(array[i]+"\t");
}
System.out.println("Sum 1~100:"+sum);
}
}
例2:
package ch04;
public class ArrayTest{
public static void main (String args[]){
int [][] array=new int [2][];
array[0]=new int [5];
array[1]=new int [3];
for (int i=0;i<array[0].length;i++){
array[0][i]=i+1;
if(i<3){
array[1][i]=i*10;
}
}
for(int j=0;j<array[0].length;j++){
System.out.print(array[0][j]+"\t");
}
System.out.println();
for(int k=0;k<array[1].length;k++){
System.out.print(array[1][k]+"\t");
}
}
}
数组中常见问题
运行时异常:
ArrayIndexOutboundException (index 越界)
NullpointerException 空指针异常
Person p1 = new Person
p1.name p1.getName()
p1=null;
p1.name p1.getName()
NullpointerException 出错。
螺旋数组
螺旋数组:二维结构 4*4
数组的拷贝
数组的拷贝:由于数组构造的一次性。当数组无法满足需求时,需要重新创建一个新的数组,并将元数组的内容拷贝到新数组中,同时把引用指向新数组。
System.arraycopy(1,2,3,4,5)
1.原数组的引用
2.原数组开始拷贝的起始索引
3.目标数组的引用
4.目标数组的插入索引位置
5.拷贝的数量
例:
static 使用static修饰方法条用时不需要类的实例。
类名.static修饰的方法(参数列表)
ch04/ArrayCopyTest.java
package ch04;
public class ArrayCopyTest{
public static void main(String args[]){
int [] srcArray=new int[100];
for(int i=0;i<srcArray.length;i++){
srcArray[i]=i+1;
}
int [] destArray=new int[50];
System.arraycopy(srcArray,50,destArray,0,50);
for(int j=0;j<destArray.length;j++){
System.out.print(destArray[j]+"\t");
}
}
}
性能测试:代码执行时间
long start = System.ourrentTimeMillis();
代码
。。。
。。。
long end = System.ourrentTimeMills();
long duration=end-start;
数组实例项目
银行排号系统
需求描述:描述程序的基本功能.
需求分析: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
/**
*Created in 2011-11-22
*
*/
package ch04;
/**
*排号系统
*@author
*@version 0.1
*/
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();
}
}
队列操作
package ch04;
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();
}
}
数组二分查找、排序、输出
ch04/ArraysTest.java
package ch04;
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();
}
}
Java基础算法题
杨辉三角
//杨辉三角
package ch03;
public class YHTest
{
public static void main(String []args)
{
int [][] array=new int[10][10];
for(int i=0;i<10;i++)
{
for(int j=0;j<=i;j++)
{
if(j==0 || i==j) //如果是第一列或者对角线
{
array[i][j]=1;
}
else
{
array[i][j]=array[i-1][j-1]+array[i-1][j];
}
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
}
最大公约数
/*
求两个数的最大公约数 与 最大公倍数
*/
package ch03;
public class MaxDivisor
{
public static void main(String []args)
{
MaxDivisor opt=new MaxDivisor();
//System.out.println(Integer.valueOf(args[0])%Integer.valueOf(args[1]));
System.out.println("最大公约数为:"+opt.commonDivisor2(Integer.valueOf(args[0]),Integer.valueOf(args[1])));
System.out.println("最小公倍数为:"+opt.commonMultiple(Integer.valueOf(args[0]),Integer.valueOf(args[1])));
//问号表达式
int b=Integer.valueOf(args[0]);
int a=(b==0 ? b:(b+2));
System.out.println("opt.ret(b): "+opt.ret(b) + "\na = "+a+" b = "+b);
System.out.println("Add(a,b) = "+opt.Add(a,b));
System.out.println("1^1:"+(1^1)); //得0
System.out.println("0^0:"+(0^0)); //得0
}
//测试问号表达式
public int ret(int b)
{
return b==0 ? b:(b+=2);
}
//最大公倍数
public int commonDivisor1(int num1,int num2)
{
return (num1%num2 == 0) ? num2:commonDivisor1(num2,num1%num2);
}
public int commonDivisor2(int num1,int num2)
{
int t,a;
if(num1<num2)
{
//shift1(num1,num2);
//shift2(num1,num2);
shift3(num1,num2);
}
while((a=num1%num2)!=0)
{
num1=num2;
num2=a;
}
return num1;
}
//最小公倍数
public int commonMultiple(int num1,int num2)
{
return num1*num2/commonDivisor1(num1,num2);
}
//交换函数
public void shift1(int num1,int num2)
{
int t=num1;
num1=num2;
num2=t;
}
public void shift2(int num1,int num2)
{
num1=num1+num2;
num2=num1-num2;
num1=num1-num2;
}
public void shift3(int num1,int num2)
{
num1=num1^num2; //异或,相同为0,不同为1,找出不同的位(异或之后,为1的位),
num2=num1^num2; //再异或得到初始num1的值赋给num2
num1=num1^num2; //再异或得到初始num2的值赋给num1
//num2的各位与0异或(两数中相同的位)保持不变,num2的各位与1异或(两数中不相同的位)反转,
}
//位运算实现加法
public int Add(int num1,int num2)
{
return num2==0 ? num1 : Add(num1^num2,(num1 & num2)<<1);
//先不计进位相加(num1^num2),得出的结果,再与进位相加,随着递归,直至进位变为0,递归结束
}
}
位运算简例
十进制转换成二进制
public class d2binary
{
public static void main(String []args)
{
int a=10;
for(int i=31;i>=0;i--)
{
System.out.print(a>>i&1); //输出二进制
}
System.out.print("\n\n");
d2binary op=new d2binary();
int b=15;
int c;
c=op.add(1,1);
System.out.println("\nAdd(10,15)-->c="+c);
}
/*交换两个变量的值,有三种方法:
1.利用位操作(异或 ^)
2.两数相加、相减、相减
3.使用中间变量
*/
//利用位操作交换两变量的值
public void shift3(int num1,int num2)
{
num1=num1^num2; //异或,相同为0,不同为1,找出不同的位(异或之后,为1的位),
num2=num1^num2; //再异或得到初始num1的值赋给num2
num1=num1^num2; //再异或得到初始num2的值赋给num1
//num2的各位与0异或(两数中相同的位)保持不变,num2的各位与1异或(两数中不相同的位)反转,
}
//从32位的单元中取出某几位
public int getMidBits(int val,int n1,int n2)
{
int z;
z=~0; //将z初始化16位的1
z=(z>>n1)&(z<<(32-n2)); //将两端的化成0,中间的化成1
z=val&z;
z=z>>(32-n2);
return z;
}
//对32的二进制数取出它的奇数位(从左边起1,3,5 。。。)
public int getOddBits(int val)
{
int z,a,q;
z=0;
for(int i=1;i<=31;i+=2)
{
q=1;
for(int j=1;j<=(32-i-1)/2;j++) //要取的数的位数为原来的数的位数的1/2
q=q*2; //原数进位指针进两位,要取的数的指针进一位
a=val >> (32-i); //将第i个位置的数移到最低位
a=a << 31; //通过左移31位,将将最低位移到最高位去,其后的位全都补0
a=a >> 31; //右移31位,将最高位移到最低,其前面的位全都补零,得到第i位
z=z+a*q; //积加取出的数
}
return z;
}
//算术右移:低位溢出,符号位不变,并用符号位补溢出的高位
//算术左移:符号位不变,低位补0
//逻辑右移:低位溢出,高位补零
//实现算术右移函数
public int shiftRightArithmetic(int val,int n)
{
int z;
z=~0;
z=z>>n;
z=~z;
z=z|(val >> n);
return z;
}
//实现逻辑右移函数
public int shiftRightLogical(int val,int n)
{
int z;
z=(~(1 >> n))&(val >> n);
return z;
}
//实现右在循环移位
public int moveRightCircle(int val,int n)
{
int z;
z=(val >> n)|(val << (32-n));
return z;
}
}
移位运算
package ch05;
public class Test1 {
public static void main(String[] args) {
System.out.println("~2="+(~2));//取反
System.out.println("2&3="+(2&3));//与
System.out.println("2|3="+(2|3));//或
System.out.println("~-5="+(~-5));//取反
System.out.println("-3^3="+(-3^3));//异或
//算术右移:低位溢出,符号位不变,并用符号位补溢出的高位
//算术左移:符号位不变,低位补0
//逻辑右移:低位溢出,高位补零
System.out.println("1>>2="+(1>>2));
System.out.println("-1>>2="+(-1>>2));
System.out.println("1<<2="+(1<<2));
System.out.println("-1<<2="+(-1<<2));
System.out.println("3>>>2="+(3>>>2));//逻辑右移
}
}
/*
~2=-3
2&3=2
2|3=3
~-5=4
-3^3=-2
1>>2=0 //算术右移
-1>>2=-1
1<<2=4 //算术左移
-1<<2=-4
3>>>2=0 //逻辑右移
*/