java基础

基本数据类型

1基本数据类型分为4类：整数，浮点，字符，boolean；

整形为byte占一个字节：-128~127；short类型占2个字节：-32768~32767；int占4个字节；long占8个字节；

浮点为float占4个字节；double占8个；

字符类型char占2个字节；

Boolean类型占1个，其值只有false和true；

2引用类型：class，interface，array，null，String；

3写法long w=99999999999999999999L;float w=3.903f/F;字符类型通常为单引号：’w’;

4Java有2进制用0b/0B开头，8进制0开头，16进制0X/0x开头

5类型之间可以自动转化和强制转化；

强制转换需要在前面加括号如：（int）doubleValue；

6表达式计算

Double result=int+char+byte；他们会转换为double，因为double是最长的那个；

System.out.println(“hello!”+’a’+7)==hello!a7;System.out.println(‘a’+7+“hello!”)==104hello!

7[条件语句]？[表达式1]：[表达式2]；条件语句为true返回第一个表达式，为false返回第二个；

控制流程

1Java是一行一行的按照顺序执行下来的；

2if语句

If（）{}else{}；

If（）{}else if(){}else if(){};

3switch

Switch(byte,short,char,int,string){

Case xxx1:{

Break;

}Case xxx1:{

Break;

}

Default:{}

}

3while循环

While(){}

Do{}while();在这个dowhile中会先执行一次然后再来做判断；

For(int b=;b<10;b++){}

使用continue结束本次循环；return结束方法；break结束循环；

类

初始化块[修饰符]{}；

先执行初始化块再执行构造方法；

静态初始化块是在类初始化的时候就执行，而不是在对象创建的时候；

 

 

 

 

 

单例模式；

懒汉式：

Private static XXX instance = null;

Private XXX(){};

Public static synchronized XXXgetInstance(){

If(instance ==null){

Instance = new XXX();

}

Return instance;

}

饿汉式：

Private static XXX instance = new XXX();

Private XXX(){};

Public static XXX getInstance(){

Return instance;

}

final类型；

被它修饰的类不能有子类；

被它修饰的变量只能赋值一次，然后就不可再被改变；

被它修饰的方法不可以重写；

Public static final String NAME=”zhangsan”;

final成员变量必须程序员显示初始化，系统不会对其进行隐式初始化；

抽象方法和抽象类

抽象方法没有方法体；

抽象类和抽象方法必须使用abstract来修饰定义；

抽象类不可以使用new来实例化，它不可以被实例化，只能当作父类被其他子类继承；

抽象类可以包括属性，方法（普通方法和抽象方法都可以），构筑2器，初始化块，内部类，枚举类；

普通类不可以包含抽象方法；

Final和static和private都不可以和abstract一起用；

抽象类主要用来做一个模版；为子类通用的模版；

接口

使用interface来修饰；

接口里面只能由抽象方法和常量，而且默认为属性添加publicstatic final；接口的方法总是使用publicabstract来修饰；

接口可以extends多个接口；接口不可以继承类，一个类只能继承一个类，但是可以同时implements多个接口；而且implements只能放在extends后面；

[修饰符] class 类名 extends 父类 implements 接口1，接口2....{}

修饰符只能是public或者default；

对象的垃圾回收机制

在堆内存中分配一块内存区，对象就是保存在这块内存区中，当这个内存不在被任何引用变量引用时，这个块内存就会变成垃圾，等待垃圾回收机制进行回收；

1垃圾回收机制只负责回收堆内存中的对象。

2程序无法精确的控制垃圾回收机制的运行。

3垃圾回收机制回收任何对象之前，总会先调用它的finalize方法。

强制垃圾回收

System.gc()/Runtime.getRuntime().gc()

 

集合：

集合分为set，list和map三种，set无序，而且不可以重复；list代表有序，可重复，map代表key-value；

Collection集合体现包括set/queue/list；

set

Set set=newHashSet();

      set.add('1');

      set.add('2');

      set.add('3');

      set.add('4');

      System.out.println(set.size());

      for(Iterator it =set.iterator();it.hasNext();){

         System.out.println(it.next().toString());

      }

hashset集合判断2个元素相等是通过equals方法比较相等和2个对象的hashCode方法返回值也是相等；

Comparable接口在该接口中有一个compareTo（Object obj）实现了接口对象大小的比较；

List

Void add(intindex,object element);

Boolean addAll(intindex,Collection o):将集合c所有的元素插入到index处；

Object get(int index)

Int indexOf(object o):返回对象出现的第一次的位置

Int lastIndexOf(objecto)

Object remove(intindex);删除并且返回index处的元素。

Object set(intindex,Object elemet):将index处的元素替换为element对象，返回新的元素。

 

 

 

 

Map

Key-value

Void clear():删除所有的健值对；

Boolean containKey(Objectkey)是否包含key；

Object get(Object key);拿取value、如果没有就返回null；

Set keySet();返回所有key成为一个set集合；

HashMap重写了toString()方法，实际上所有的map都重写了toString方法；格式如下

[key1=value1，key2=value2]

 

常用类

Object是所有类的父类，equals方法；hashCode方法，toString方法

String

Boolean endsWith(Stringaabb);判断该对象是否为aabb结尾

Boolean equals(Objectobj):将字符串与知道对象比较

BooleanequalsIgnoreCase(String str);忽略大小写

Byte[] getByte();将该string对象转换为byte数组

Int indexOf(Stringstr):找到str字符串在该字符串第一次出现的位置。

Int lastIndexOf(Stringstr);最后一次出现的位置

String subString(intbegin,int end);从下标为begin开始，包括下标begin，到下标end-1，包括end-1；

StringBuffer （线程安全，builder不安全）

Append（）

toString可以将其转换为String类型；

Math

PI=3.1415926....

BigDecimal

Math.random()生成0-1之间的小数

Random有2个构造器，一个使用默认种子，还有一个需要我们输入一个long型整数的种子。同一个seed，产生的随机数相同

Public Random(longseed):需要输入一个seed

Public int nextInt();产生一个随机的整数

Public long nextLong();

Public floatnextFloat();

Public doublenextDouble();

Date

Date();

Int compareTo(Datedate):==------0；〉----->0;<---<0;

Long getTime;以毫秒为单位

Void setTime(longtime);

 

 

 

 

IO

File类

String getName();返回对象所表示的文件名或路径名

String getPath();返回路径名

StringGetAbsolutePath();返回绝对路径名；

Boolean exists();判断file对象文件或目录是否存在

Boolean isFile();判断file对象对应的是文件不是目录；

Boolean isDirectory();判断file对象对应的是目录不是文件；

Long lastModified();返回文件最后修改时间；

Long length();返回文件内容的长度；

Boolean mkdir();创建一个目录；

BooleancreateNewFile();当file对象对应的文件不存在的时候，该方法将创建一个新文件。

Boolean delete();删除file对象对应的文件

 

InputStream和Reader

InputStream的常用方法

Int read();从输入流读取单个字节，返回值为读取字节数据

Int read(byte[] b);从输入流最多读取b.length个字节，存在数组b中，返回实际读取的字节数

Int read(byte[] b,intoff,int len);从输入流中最多读取len歌字节，存在数组b时是从off位置开始的，返回实际读取的字节数

Reader类

Int read();读取单个字符，返回读取的字符数据

Int read(char[] obuf);从输入流中最多读取读取obuf.length个字符数据，存入数组中，返回实际读取的字符数。

Int read(char[]obuf,int off,int len)

 

OutputStream类

Void write(int c);将指定的字节/字符输出到输出流中，其中c可以代表字节，或者字符；

Void writ(byte[]/char[]buf);将字节/字符数组的数据输入到指定的输出流中

Voidwrite(byte[]/char[] buf,int off,int len)从off位置开始，输出长度为len

Writer类

Void write(String str):将str字符串输出到输出流中。

Void writer(Stringstr,int off,int len);

使用JavaIO时记得在finally中关闭输入流和输出流。

private static void copyFile(){

        //将字节输入流转换为字符输入流

        InputStreamReader isr = null;

        //将字节输出流转换为字符输出流

        OutputStreamWriter osw = null;

        try {

            //创建了一个字节输入流

            InputStream is = newFileInputStream("D:\\code\\天龙八部.txt");

           

            isr = newInputStreamReader(is);

            //创建了一个字节输出流

            OutputStream os =newFileOutputStream("D:\\code\\老版天龙八部.txt");

            osw = newOutputStreamWriter(os);

            //创建一个字符数组，用来存储读取到的内容

            char[] chars =new char[10];

            //用来接收读取到的字符个数

            intcount;

            while((count = isr.read(chars)) != -1){

                //输出读取到的内容

                System.out.println(newString(chars,0,count));

                //将读取到的内容写入到字符输出流中

                osw.write(chars, 0, count);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                //关闭字符输出流

                if(osw !=null){

                    osw.flush();

                    osw.close();

                    osw = null;

                }

                //关闭字符输入流

                if(isr !=null){

                    isr.close();

                    isr = null;

                }

            } catch (Exception e2) {

                e2.printStackTrace();

            }

        }

    }

 

线程

步骤

1继承Thread类或者实现Runnable接口，重新写run方法。

2创建Thread子类或runnable的实现类，即创建线程对象，不同的是接口实现线程需要将接口实现类作为参数传递给Thread类的构造参数。

3调用线程对象的start方法启动线程

Run方法是执行任务的

Start是启动线程的

一个线程只能被启动一次

线程有new---runnable---running---blocked---dead；

线程阻塞

Sleep；调用阻塞IO；想获取一个同步监视器，但正在被别人使用；等待某个通知notify；挂起；

线程死亡：

Run方法正常结束；

线程异常或者error；

Stop；

Join方法用于让一个线程等待另一个线程完成的方法；

Yield让当前线程停一下；