基础整理

 

一基础

dos命令行，课程中常见命令：

dir：列出当前目录下的文件及文件夹

md：c创建目录

rd：删除目录

cd：进入指定目录

cd..：退回到上一级目录

cd/：退回到根目录

del：删除文件夹

exit：退出dos命令行

cls：清屏

java虚拟机JVM（JAVA Virtul Machine）

JRE：java runtime environment java运行环境

JDK：java development kit java开发工具包

Garbage Collection垃圾收集机制

API :Application Programming Interface

用于定义数据类型的关键字

class  interface enum  byte short int long    float  double char  boolean void

用于定义数据类型值的关键字

True  false    null

用于定义流程控制的关键字

if else switch case   default   while do for break  continue  return

用于定义访问权限修饰符的关键字

private protected   public

用于定义类，函数，变量修饰符的关键字

abstract final   static synchronized

用于定义类与类之间关系的关键字

extends implements

用于定义建立实例及引用实例，判断实例的

new   this super instanceof

用于异常处理的关键字

try catch finally throw throws

用于包的关键字

package import

其他修饰符关键字

native strictfp transient volatile assert

运算符 运算 范例 结果

+ 正号 +3 3

- 负号 b=4; -b -4

+ 加 5+5 10

- 减 6-4 2

* 乘 3*4 12

/ 除 5/5 1

% 取模 5%5 0

运算符 运算 范例 结果

++ 自增（前）：先运算后取值a=2;b=++a; a=3;b=3 （后）：先取值后运算a=2;b=a++; a=3;b=2

- - 自减（前）：先运算后取值a=2;b=- -a a=1;b=1（后）：先取值后运算a=2;b=a- - a=1;b=2

+ 字符串相加“He”+”llo” “Hello”

== 相等于 4==3  false

!= 不等于 4!=3  true

< 小于 4<3  false

> 大于 4>3  true

<= 小于等于4<=3  false

>= 大于等于4>=3  false

instanceof 检查是否是类的对象“Hello”instanceof String true

& AND(与) false & true false

| OR(或) false|true true

^ XOR(异或) true^false true

! Not(非) !true false

&& AND(短路) false&&true false

|| OR(短路)  false||true true

 

位运算符的细节

<< 被移除的高位丢弃，空缺位补0。

>> 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。

>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补。

& 二进制位进行&运算，只有1&1时结果是1，否则是0;

| 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;

^ 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1

运算符 运算 范例

<< 左移 3 << 2 = 12 --> 3*2*2=12

>> 右移 3 >> 1 = 1  --> 3/2=1

>>> 无符号右移 3 >>> 1 = 1 --> 3/2=1

运算符 运算 范例

& 与运算 6 & 3 = 2

| 或运算 6 | 3 = 7

^ 异或运算6 ^ 3 = 5

~ 反码 ~6 = -7

 

二数组

创建数组int[] arr=new int[5];

获取到数组元素个数arr.length

二维数组int[][]arr = new int [3][4];

 

三面向对象

封装  (Encapsulation)

继承  (Inheritance)

多态  (Polymorphism)

类(class)和对象(object)实例(instance)

java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

java.applet----包含applet运行所需的一些类。

java.net----包含执行与网络相关的操作的类。

java.io----包含能提供多种输入/输出功能的类。

java.util----包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。

基本数据类型  封装类

boolean       Boolean

byte           Byte

short       Short

int            Integer

long           Long

char           Character

float           Float

double       Double

提取说明文档dos命令javadoc -d(目录) myhelp(存放在这个目录里)-author()作者arraytool.java

单例设计模式：

1，将构造函数私有化2，在类中创建一个本类对象3，提供一个方法可以获取到该对象

获取时间：System.currentTimeMillis();

 

内部类问题:

建立内部类对象Outer.Inter in = new Outer().new Inter();

内部类的访问规则：

1，内部类可以直接访问外部类中的成员，包括被私有的。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

2，外部类要访问内部类必须建立内部类对象

内部类定义在局部时，1，不可以被成员修饰符修饰 2，可以直接访问外部类中的成员

因为还持有外部类中的引用。但是不可以访问它所在局部中的变量，只能访问被final

修饰的局部变量。

匿名内部类：

1，匿名内部类就是内部类的简写格式。

2,定义匿名内部类的前提：内部类必须是继承一个类或实现接口。

3,匿名内部类的格式：new 父类或接口(指构造函数){定义子类的内容}.调用方法

4，匿名内部类就是一个匿名子类对象。且这个对象有点胖，可以理解为带内容的对象

5，匿名内部类中定义的 方法最好不要超过3个。

 

 

 

异常体系：

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。

也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。

throw和throws的用法：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

注意：RuntimeException除外，也就是说，函数内如果抛出的为RuntimeException异常，函数上可以不用声明，

如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try。

异常有两种：

编译时被检测的异常

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败

该异常被标识，代表着可以被处理。

运行时异常(编译时不被检测)

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

定义类继承Exception或者RuntimeException

1，为了让自定义类具备可抛性。

2，让该类具备操作异常的共性方法。

异常的好处：

1，将问题进行封装。

2，将正常的流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1，处理方式有两种：try或者throws。

2，调用到抛出异常的功能时，抛出几个处理几个。一个try对应多个catch。

3，多个catch，父类的catch放到最下面。

4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。

也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

注意：

1，finally中定义的通常是 关闭资源代码，因为资源必须释放。

2，finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行。

异常的注意事项：

在子父类覆盖时：

1，子类抛出的异常必须是父类的异常的子类或子集。

2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

 

操作命令

e.getMessage();异常信息

e.toString();异常名，异常信息

e.printStackTrace();异常名称，异常信息，异常出现的位置

ArithmeticException算术异常

ArrayIndexOutOfBoundsException角标越界异常

ConcurrentModificationException并发访问修改异常

UnsupportedOperationException//不支持操作异常

 

四多线程

创建新执行线程的方法：

步骤：1，定义类继承Thread。2，复写Thread类中的run方法，目的是将自定义方法存储在run方法中让线程运行。3，调用线程的start方法，该方法有两个作用：启动线程，调用run方法

创建线程的另一种方法是声明实现Runnable接口类，该类然后实现run方法，然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。

步骤：1，定义类实现Runnable接口 2，覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。3，通过Thread类建立线程对象。4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数因为，自定义的run方法所属的对象是Runnable接口的子类对象，所以要用线程去指定对象的run方法，就必须明确该run方法所属对象。5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

为什么要覆盖run方法呢？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

实现方式和继承方式的区别：实现方式的好处：避免了单继承的局限性，在定义线程时，建议使用实现方式。

区别在于：继承Thread：线程代码存放在Thread子类run方法中 实现Runnable，线程代码存在接口的子类run方法中。

同步前提：1，必须要有两个或者两个以上的线程。2，必须是多个线程使用同一个锁

必须保证同步中只能有一个线程在运行，好处：解决了多线程的安全问题

弊端：多个线程都要判断锁，比较消耗资源。

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁。

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒，不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁，而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

 

操作命令

Thread.currentThread().getName()获取当前线程名称。也可理解为this.getName().

static Thread currentThread():获取当前线程对象。

getName():获取线程名称。

setName设置线程名称或者构造函数法

t1.start(); 启动线程

synchronized(对象)直接建立Object的对象传进来即可

try{Thread.sleep();}catch (Exception e){}休眠功能用法

public synchronized void add(int n){}同步函数 和同步代码块功能类似

wait(); notify();notifyAll();wait()使用时注意要抛或try

JDK 1.5 Condition对象lock.newCondition().await()，lock.newCondition().signal(),  lock.newCondition().signalAll().该对象可以通过Lock锁进行获取。在该示例中，实现了只唤醒对方的操作。

private Lock lock = new ReentrantLock();建立锁

private Condition condition_sc = lock.newCondition();利用其对象调用功能。

private Condition condition_xf = lock.newCondition();

interrupt();强制让线程恢复到运行状态

t1.setDaemon(true)标记t1为守护线程。

join特点：当A线程执行到了B线程的.join()方法时，A等待，等B执行完，A才会执行。

toString();包括线程名称，优先级，线程组

setPriority()设置优先级MAX_PRIORITY 最低MIN_PRIORITY 默认NORM_PRIORITY

yield()暂停当前正在执行的线程对象，并执行其他线程。

 

五String字符串正则表达式

String s1 = "abc";s1是一个类类型变量，abc是一个对象。字符串特点：一旦被初始化就不可以被改变。

String s2 = new String(abc);使用方法与上方一样但有区别。s1==s2不成立。s1.equals(s2);成立 因为String类复写了Object类中的equuals方法

StringBuffer是字符串缓冲区.特点:是一个容器.而且长度可变化,可以直接操作多个数据类型 最终通过toString方法变成字符串

JDK1.5之后出现StringBuilder 与StringBuffer不同. StringBuilder是线程不同步 StringBuffer是线程同步 一般选用StringBuilder虽然不安全但更高效

正则表达式:符合一定规则的表达式,专门用来操作字符串

好处:可以简化对字符串的复杂操作

弊端:符号定义越多正则越长阅读性越差

获取:将字符串中符合规则的子串取出; 操作步骤:1,将正则封装成对象 2,让正则对象和要操作的字符串相关联 3,关联后,获取正则匹配引擎 4,对子串操作

String reg = "\\b[a-z]{4}\\b";定义规则\\b表示单词分割符

Pattern p = Pattern.compile(reg);规则封装成对象

Matcher m = p.matcher(str);将正则对象和要作用的字符串相关联

m.find()如果存在符合规则

m.group();获取符合规则的字符串

m.start();获取开始的位置 m.end();获取结束的位置

 

操作命令

int length();获取字符串长度。

char charAt(int index);根据位置获取位置上某个字符。

int indexOf(int ch)返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。

boolean contains(str):判断字符串是否存在是否包含.

boolean ifEmpty():原理就是判断长度是否为0

boolean startsWith(str);字符串是否是以指定内容开头

boolean endsWith(str);字符串是否是以指定内容结尾

boolean equals(str);字符串内容是否相同,复写了Object类中的equals

boolean equalsIgnoreCase();内容是否相同并忽略大小写

String(char[]);构造函数将字符数组转换成字符串.

String(char[],offset,count):将字符数组中的一部分转换成字符串.

static String copyValueof(char[]); 

static String copyValueof(char[]data,int offset,int count) ;

char[] toCharArray();字符串转换成字符数组

String(byte[]) 字节数组转换成字符串.

String(byte[],offset,count):将字节数组中的一部分转换成字符串.

byte[] getBytes();字符串转化成字节数组

static String valeueof(int)基本数据类型转换成字符串.  static String valueof(double)  3+"";

String replace(oldchar,newchar);新的替换老的.

String[]split(regex);切割

String substring(begin); String substring(begin,end); 获取字符串中的一部分.

String toUpperCase(); String toLowerCase();字符串转换成大写或小写.

String trim();字符串两端的多个空格去除.

int compareTo(String);对两个字符串进行自然顺序的比较.

 

StringBuffer 方法

StringBuffer append();将指定数据作为参数添加到已有数据结尾处. 

StringBuffer insert(index,数据);可以将数据插入指定index位置.

StringBuffer delete(start,end)删除缓冲区中的数据,包含start不包含end.  

StringBuffer deleteCharAt();删除指定位置的字符

char charAt(int index);  int indexOf(String str);  int lastIndexOf(String str);  

int length();  String substring(int start,int end)

StringBuffer replace(start,end,String);指定范围替换  

void SetCharAt(int index,char ch);指定位置替换.

StringBuffer reverse();反转字符串.

void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);指定数据,存储到指定的字符数组

基本数据类型 +""基本数据类型转成字符串

toString(基本数据类型值);基本数据类型转成字符串.

字符串转成基本数据类型xxx a = Xxx.parseXxx(String);int a = Integer.parseInt("123");

Integer i = new Integer("123");

int num = i.intValue();对象变为int型值。

toBinaryString();toHexString();toOctaltring();十进制转成其他进制

parseInt(String,radix);其他进制转成十进制 int x = Integer.parseInt("3c",16);16表示16进制

Integer x = new Integer("123");Integer y = new Integer(123);x==y;不成立 x.equals()y;成立

 

正则方法

String matches();方法,用规则匹配整个字符串一处不符合即为false

String split();切割

replaceAll("(.)//1","$1");$1表示替换为替换为第一个组的数据

String matches方法查阅正则规则

String regex = "[1-9][0-9]{4,14}";定义规则1-9开头,第二位可选0-9,往后适用4-14皆可

boolean falg = qq.matches(regex);判断是否符合定义规则

Pattern p = Pattern.compile(reg);规则封装成对象

Matcher m = p.matcher(str);将正则对象和要作用的字符串相关联

m.find()如果存在符合规则

m.group();获取符合规则的字符串

m.start();获取开始的位置 m.end();获取结束的位置

 

六集合

集合框架：

Collection:

|--List:元素有序可以重复,因为集合体系有索引

|--ArrayList:底层的数据结构使用的是数组结构.特点查询速度快,但是增删稍慢.线程不同步

|--LinkedList:底层使用的链表数据结构.特点增删速度快,但是查询稍慢

|--Vector:底层数组数据结构.线程同步.被ArrayList替代了.

|--Set:元素无序(存入和取出的顺序不一致)不可重复.功能和Collection是一致的

|--HashSet:底层数据结构是哈希表.

HashSet是如何保证元素唯一性的?是通过元素的两个方法,hashCode和equals来完成当元素的hashCode值相同才会判断equals是否为true反之则不调用equals.

注意:对于判断元素是否存在以及删除操作,依赖的方法是元素的hashCode和equals方法.

|--TreeSet:可以对Set集合中的元素进行排序,底层数据结构是二叉树,保证元素唯一性的依据compareTo方法return 0;

TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法,这种方式也称为元素的自然顺序.

TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的这时就需要让集合自身具备比较性 在集合初始化时就有了比较方式

对象复写Comparable接口的compareTo方法。比较器 Comparator接口的compare方法 次要条件比较用compareTo方法

泛型:JDK1.5版本之后出现的新特性,用于解决安全问题,是一个安全机制

好处:1,将运行时期出现问题ClassCastException,转移到了编译时期,方便程序员解决问题.

 2,避免了强制转换麻烦

泛型的格式:通过<>来定义要操作的引用数据类型,在使用将java提供的对象时,什么时候写泛型呢?通常在集合框架中很常见,只要见到<>就要定义泛型.<>用于接收类型.使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可

泛型方法:

泛型类定义的泛型在整个类中有效,如果被方法使用,泛型类的对象明确要操作的具体类型后,所要操作的类型已经固定

为了让不同方法可以操作不同类型,而且类型还不确定可以将泛型定义在方法上.

特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上

public static <w> void method(W t)泛型放在返回值类型之前

 

Map集合：该集合存储键值对,一对一往里存保证键的唯一性

|--Hashtable:底层是哈希表数据结构,不可以存入null键null值.该集合是线程同步的,jdk1.0效率低

|--HashMap:底层是哈希表数据结构,可以存入null键null值.该集合是线程不同步的,jdk1.2效率高

|--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键进行排序

Map和Set很像,Set的底层就是使用了Map集合.

map集合的两种取出方式:

1,Set<k> keySet:将map中所有的键存入到Set集合,因为set具备迭代器,可以用迭代器方式取出所有的键 再根据get方法获取每一个键对应的值.原理:将map集合转成Set集合再通过迭代器取出

2,Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry

 

操作命令

Iterator it = al.iterator();获取迭代器.用于取出集合中的元素

it.hasNext())判断是否还能取到值

it.next());取到下一个值

al1.retainAll(al2);取交集,al1中只会保留和al2中相同的元素

al1.removeAll(al2);除去al1中和al2中相同的元素.

al.remove("java02");删除元素

al.clear();清空集合

al.contains("java03")java03是否存在

al.isEmpty()集合是否为空

al.size();,获取元素个数,集合长度.

 

List

增add(index,element);addAll(index,Collection);

删remove(index);

改set(index,element);

查get(index);

al.subList(1,3);获取1-3角标元素 含头不含尾

al.indexOf("java02"); 获取对象位置 

ListIterator lis = al.listIterator();list特有迭代器可增删操作

li.hasPrevious()判断是否有前一个元素

li.previous()从后面开始遍历

 

Vector

Enumeration en = v.elements();枚举en.hasMoreElements();en.nextElement()

addFirst();

addLast();

getFirst();

getLast();

removeFirst();

removeLast();

JDK1.6

offerFirst();添加

offerLast();

peakFirst();获取

peakLast();

pollFirst();删除

pollLast();

删除或获取的元素不存在会返回null

 

public int hashCode()复写hashCode

public boolean equals(Object obj)复写Object的equals方法

public int compareTo(Object obj)复写Comparable的compareTo方法

public int compare(Object o1,Object o2)复写 Comparator的compare方法

public static <w> void method(W t)泛型放在返回值类型之前

interface Inter<T>泛型定义在接口上

<?>  通配符。可理解为占位符 即类型不确定的时候可以其都能应用

<? extends E>可以接收E类型或E类型的子类型。 上限

<? super E>可以接收E类型或者E的父类型。 下限

 

Map

put(K key,V value)返回值为键原来指向的值  putAll(Map<? extends K,? extends V>m)

clear()  remove(Object key)删除

containValue(Object value) containKey(Object key)  isEmpty()判断

get(Object key)  size()  Values()  entrySet()  keySet()获取

TreeMap<Student,String> map = new TreeMap<Student,String>(new StuNaCom());传入比较器

 

七工具类

Collection

Collections:方法都是静态的无需对象直接类名调用

public static<T extends Comparable<? super T>> void sort(List<> list)泛型限定为必须是Comparable子类,这样才能具备比较性

Collections.sort()集合元素自然排序.

Collections.sort(list,new StrLenComparator());按照指定方法排序

Collections.binarySearch(list,"tt");//查找集合中元素并返还应存在位置

Collections.max(list);获取集合中最大值

Collections.fill(list,"pp");将list集合中的元素都替换成"pp".

Collections.replaceAll(List list,"aaa","pp");将list集合中的aaa替换成pp

Collections.reverse(List list);将list集合中元素反转

Collections.reverseOrder();对比较器方式强行逆转

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());

Collections.synchroinzedList(List list)//将List不同步的集合变为同步.

Collections.swap(List list,int i,int j);置换list集合中两个元素的位置

Collections.shuffle(List list);对list进行重新随机排序.

 

Ayyays

Arrays.toString(arr)将数组转为字符串。

List<int[]> li = Arrays.asList(nums);将数组变成List集合。

al.toArray(new String[al.size()]);集合变数组

for (数据类型 变量名:被遍历的集合(Collection)或者数组 )高级for循环

public static void show(int... arr)不用函数重载可变参数

import static java.util.Arrays.*;导入Array这个类中的所以静态成员

import static java.uril.System.*;导入System类中的所有静态成员

 

System

out:标准输出,默认是控制台

in:标准输入,默认是键盘

Properties getProperties();获取系统属性信息

Properties prop = System.getProperties();

System.getProperty("os.name");获取装机的操作系统window Xp

System.getProperty("haha");通过haha键获取值系统中没有应为null 

java -Dhaha=ppp SystemDemo 此时哈哈对应为ppp

 

Runtime

Runtime r = Runtime.getRuntime();获取本类对象

r.exec("notepad.exe e:\\abc\\Demo.java");会将Demo.java文件以记事本的形式打开

p.destroy();会结束上面开启的程序 即进程

 

Date

Date d = new Date();创建对象

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss")明确格式

sdf.format(d);调用format方法让模式格式化指定Date对象

 

Calendar

Calendar c = Calendar.getInstace();获取当前时间详细值

c.get(Calendar.YEAR) 年;

c.get(Calendar.MONTH) 月;

c.get(Calendar.DAY_OF_MONTH) 日;

c.get(Calendar.DAY_OF_WEEK) 星期;

add(被操作时间,操作的是年还是月,操作+ - int)

c.set(2012,2,23);打印的是2012年3月23日

 

Math

Math.ceil(16.33);返回大于指定数据的最小整数

Math.floor(12.32);返回小于指定数据的最大整数

Math.round(13.54);四舍五入

Math.pow(2,3);2的3次方

Math.random();取得包含0不包含1之间的伪随机数 

int d =(int)(Math.random()*10+1);得到1-10的随机整数 

Random r =new Random();int d= r.nextInt(10);伪随机获取0-9之间的一个整数

 

八IO流

操作数据:字节流InputStream,OutputStream 字符流Reader,Writer

流向分:输入流和输出流

装饰设计模式与继承模式的区别:

装饰设计模式比继承模式要灵活,避免了继承体系的臃肿,降低了类与类之间的关系

装饰类因为增强已有对象已具备的功能,所以具备和已有对象相同的功能,只是功能更强

因此装饰类和被装饰类通常都属于一个体系,即相同的父类或接口

流操作的基本规律:

1,明确源和目的.

源:输入流 InputStream Reader

目的:输出流 OutputStream Writer

2,操作的数据是否为纯文本

是:字符流操作

不是:字节流操作

3,体系明确后再明确具体使用对象

通过设备进行区分

源设备:内存,硬盘,键盘

目的设备:内存,硬盘,控制台

将info.txt中的键值数据存入到集合中

思路:1,用一个流和info.txt文件关联 2,读取一行数据,将该行数据用"="切割 3,"="左右键值存入集合

Properties提供的load(流对象file);可以直接将文件中的数据加载进集合中.list(System.out);打印出集合元素列表  

prop.store(fos,"haha");方法应用:FileOutputStream fos = new FileOutputStream("info.txt");此时store方法将集合内容重新存入文件"haha"为一个标记

打印流:

提供打印方法,可以将各种数据类型的数据都原样打印

字节打印流:PrintSream 构造函数可以接收的参数类型:

1,File对象.File 2,字符串路径.String 3,字节输出流OutputStream

字符打印流:PrintWriter构造函数可以接收的参数类型:

1,File对象,File 2,字符串路径.String 3,字节输出流.OutputStream 4,字符输出流,Writer

对象序列化:

对象要被序列化必须实现Serializable标记接口 可自定义序列号防止对象改变文件失败

public static final long serialVersionUID = 3672L;

如果不想对象中成员序列化加transient修饰 例如 transient int age;则age不再被序列化 静态也不能序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

oos.writeObject(new Person("lisi",28));用writerObject()方法写入对象

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

Person p =(Person)ois.readObject();方法从文件中读取对象

 

管道流:

PipedOutputStream管道输出流 PipedInputStream管道输入流 可以用connect()或构造函数链接

双线程执行

 

RandomAccessFile:

该类不属于IO体系,直接继承Object类.是IO包中成员具备读写功能,内部封装一个数组通过指针对元素进行操作

getFilePointer获取指针位置 通过seek改变指针位置 内部封装字节输入输出流 rw来操作读写功能

如果模式为只读r,不会创建文件,会去读取一个已存在文件,文件不存在则报异常

如果为rw,操作的文件不存在会自动创建,存在不覆盖.

RandomAccessFile raf = new RandomAccessFile("t.txt","rw");具备读写功能

skipBytes();跳过指定字节数,只能一直往后跳 waiteInt();readInt();读写int型数据

可以直接在指定位置进行写入和修改

 

DataInputStream DataOutputStream可以用于操作基本数据类型的数据流对象要接收相应的字节流writeUTF();写只能readUTF();读

 

ByteArrayInputStream构造时需要接收一个字节数组的源 ByteArrayOutputStream构造时不需要定义数据目的,内部自定义了可变长度字节数组

两个操作字节数组的流对象没有使用系统资源 无需关闭且不存在异常 writeTo(new OutputStream("a.txt"));直接写入目的文件

操作字符数组:CharArrayReader CharArrayWriter 操作字符串StringReader StringWriter与字节数组的操作类似

指定编码表操作:

InputStreamReader(new FileInputStream("gbk.txt"),"gbk");指定编码读取 OutputStreamWriter()

byte[] b = s.getBytes("gbk");用gbk码表将字符串s装入数组 String ss = new String(b,"Gbk");将数组b用gbk码表变回字符串

出现乱码的话要先用解码的码表编码再用正确对应的码表进行解码

"联通"两个汉字的码要注意 因为符合utf-8的规则所以记事本会按照utf-8的码表解码,再加入其他字就可

 

操作命令

FileWriter fw = new FileWriter("demo.txt",true);true参数代表不覆盖已有文件并在其末尾续写

fw.write("asffe");在流中写入字符串

fw.flush();刷新流对象中的缓冲中的数据.将数据刷到目的文件中

fw.clouse;关闭流资源,关闭之前会刷新一次内部的缓冲中的数据

flush和close区别:flush刷新后流可以继续使用.clouse刷新后会关闭流

FileReader fr = new FileReader("demo.txt");

int ch = fr.read();读取文件第一个字符返回值为int 返回-1则到最后了

BufferedReader br = new BufferedReader(fr);字符流缓冲区

br.readLine())

bw.newLine();

LineNumberReader lnr = new LineNumberReader(new FileReader("demo.txt"));带行号的缓冲区

lnr.setLineNumber(20);设置行号开始值为21

lnr.getLineNumber()获取行号

FileOutputStream fos = new FileOutputStream("demo.txt");

FileInputStream fis = new FileInputStream("demo.txt");

fis.available();读取出文件内字节长度

BufferedInputStream buf = new BufferedInputStream(new FileInputStream("demo.mp3"));

BufferedOutputStream buf=new BufferedOutputStream(new FileOutputStream("demo_1.mp3"));

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));键盘录入

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));控制台输出

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8");

log4j网上专门提供的异常记录工具

File f1 = new File("a.txt"); File f2 = new File("c:\\abc","b.txt");

File d = new File("c:\\abc"); File f3 = new File(d,"c.txt");

File.separator路径分割符即"c:"+File.separator+"abc"

boolean createNewFile():在指定位置创建文件,如果该文件已经存在,则不创建,返回false

boolean mkdir();创建目录 

boolean mkdirs();创建多级目录

boolean delete():删除失败返回false

void deleteOnExit():在程序退出时删除指定文件

boolean exidts():文件是否存在 

isFile():是否为文件 

isDirectory():是否为文件夹

isHidden():是否为隐藏文件 

isAbsolute():是否为绝对目录

getName();获取名称 

getPath();获取路径 

getParent()返回绝对路径中的父目录,如果是相对路径返回null有上层目录时返回上层目录

getAbsolutePath():获取绝对路径 

lastModified():最后修改时间 

length():返回文件大小 

f1.rennameTo(f2);f1替换为f2

list():列出目录下文件列表 调用list方法的file对象必须是封装了一个目录.且必须存在

listRoots():列出盘符 

listFiles():返回为对象可以具体操作

Properties prop = new Properties();

prop.setProperty("lise","24");存值

prop.setProperty("lise","29");修改

Set<String> names = prop.stringPropertyNames();将键存入Set集合中

prop.getProperty(name);获取键所对应的值

prop.store(fos,"haha");FileOutputStream fos = new FileOutputStream("info.txt");将集合内容重新存入文件"haha"为一个标记

prop.load(fis);Properties load(流对象file);可以直接将文件中的数据加载进集合中

list(System.out);打印出集合元素列表 

PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);ture 自能刷新流对象

out.println(line.toUpperCase());println自持上面的自动刷新

 

合并流

ArrayList<FileInputStream> v = new ArrayList<FileInputStream>();

v.add(new FileInputStream("e:\\abc\\a\\"+x+".part"));

final Iterator<FileInputStream> it = v.iterator();

Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()

SequenceInputStream sis = new SequenceInputStream(en);

 

序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

oos.writeObject(new Person("lisi",28));用writerObject()方法写入对象

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

Person p =(Person)ois.readObject();方法从文件中读取对象

 

九图形化界面

图形化界面布局:

FlowLayout(流式布局) BorderLayout(边界布局) GridLayout(网格布局) CardLayout(卡片布局) GridBagLayout(网格包布局)

 

创建图形化界面:

1,创建Frame窗体 2,对窗体大小进行基本设置 大小 位置 布局 3,定义组件 4,将组件通过窗体的add方法添加到窗体中 5,显示窗体setVisible(true);

事件监听机制的特点:

1,事件源:awt包或者swing包中的图形界面组件 2,事件:源都有自己特有的对应事件和共性事件 

3,监听器:将可以触发某一事件的动作(不止一个动作)封装到监视器中 以上在java中都定义好直接取其对象使用即可

4,事件处理:需要自定义处理方式或默认的

WindowListener的子类WindowAdapter已经实现了WindowListener接口并覆盖其中所有方法,只需继承WindowAdapter方法即可

windowClosing(WindowEvent e)关闭窗口 windowActivated(WindowEvent e)激活窗口 windowOpened(WindowEvent e)打开窗口

按钮添加事件:活动监听器

b.addActionListener(new ActionListener()

public void actionPerformed(ActionEvent e)

jar包双击执行:

将文件封装在包中,然后同自定义配置信息内部Main-Class: package.主类名+Enter 一同 -cvfm 打成jar包

工具文件夹选项文件类型 新建.jar扩展名文件高级 新建open浏览应用程序选择关联上javaw.exe -jar

 

操作命令

Frame f = new Frame("窗口");默认边界式布局

f.setBounds(300,200,300,200);

f.setSize(300,200);设置大小

f.setLocation(300,200);设置显示位置

f.setLayout(new FlowLayout());设置布局方案

Button b = new Button("小按钮");创建一个按钮

f.add(b);添加进按钮

f.setVisible(true);显示窗口

windowClosing(WindowEvent e)关闭窗口 

windowActivated(WindowEvent e)激活窗口 

windowOpened(WindowEvent e)打开窗口

b.addActionListener(new ActionListener() 方法public void actionPerformed(ActionEvent e)

按钮添加事件:活动监听器

 

鼠标事件:

b.addMouseListener(new MouseAdapter()

public void mouseEbtered(MouseEvent e)鼠标进入

public void mouseClicked(MouseEvent e)鼠标点击

e.getClicked()获取鼠标点击次数

 

键盘事件:

t.addKeyListener(new KeyAdapter()

public void keyPressed(KeyEvent e)键盘按下

e.getKeyCode()获取按下的键的值 e.getChar()获取按键ABC

e.isControlDown() && e.getKeyCode()==KeyEvent.VK_A 表示ctrl键和a键同时按下

KeyEvent.VK_A获取a键的值 e.isControlDown()判断ctrl键是否按下

e.consume()不按默认方式处理 TextField 文本框

 

对话框Dialog:

Dialog dig = new Dialog(Frame f,提示信息,true);true阻止上层所属对话框操作

dig.setBounds();设置位置大小 dig.setlayout(new FlowLayout());设置布局

Label lab = new Label();封装信息 dig.add(lab); String info = "信息"; lab.setText(info);

 

创建菜单:

private Frame f = new Frame("窗口");; 

private MenuBar mb = new MenuBar();用于往窗口上添加

private Menu m = new Menu("文件");菜单

private MenuItem closeItem = new MenuItem("退出");菜单上的功能选项

m.add(closeItem);

mb.add(m);

f.setMenuBar(mb);

 

打开文件:

FileDialog = new FileDialog(f,"我要打开",FileDialog.LOAD);

FileDialog = new FileDialog(f,"我要保存",FileDialog.SAVE);

十网络编程

网络编程:

找到对方IP通过数字端口标识指定程序 定义通信规则TCP/IP

OSI TCP/IP两个网络模型

端口:1-1024保留 1-65535任选

 

传输协议:

UDP:面向无连接 数据封包大小限制64K以内不可靠 速度快 DatagramSocket

TCP:数据连接 三握手连接 效率稍低

Socket:通信两端都要有才能连接通信 两个通过IO传输

UDP发送文件:

思路:1,建立Udpsocket服务 2,提供数据并封装成数据包 3,通过socket服务发送功能发送 4,关闭资源

UDP接收文件:

思路:1,定义udpsocket服务,监听端口,定义数字标识匹配端口 2,定义数据包存储接收到的字节数据 

3,通过socket服务的receive方法接收数据存入已有数据包

4,通过对象的特有功能将数据取出打印在控制台上 5,关闭资源

建立结束标识:

Socket提供关闭方法

s.shutdownOutput();关闭客户端输出流,想到在流中加入标记-1

 

操作命令

InetAddress.getLocalHost();获取本地主机

InetAddress id = InetAddress.getAllByName("地址或名称");获取对象

id.getHostAddress();获取地址 id.getHostName();获取名称

 

UDP

发送:

DatagramSocket ds = new DatagramSocket();也可指定发送端口建立udp服务

确定数据并封装byte[]buf = "upd ge men lai le".getBytes();

DatagramPacket p=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.16",100));

ds.send(p);通过socket服务将已有数据包用send方法发送出去

ds.close();关闭资源

接收:

DatagramSocket sd = new DatagramSocket(10000);指定监听端口建立udp socket端点

byte[] buf = new byte[1024];定义数据包存储数据

DatagramPacket dp = new DatagramPacket(buf,buf.length);

sd.receive(dp);通过服务的receive方法将接收到的数据存入数据包

通过数据包的方法获取数据

String ip = dp.getInetAddress().getHostAddress();

String data = new String(dp.getData(),0,dp.getLength());

int port = dp.getPort();

 

TCP

Socket客户端:

Socket s = new Socket("192.168.1.254",1000);创建客户端Socket服务,指定主机和端口

OutputStream out = s.getOutputStream();out.write("ssfdf".getBytes());发送数据

InputStream in = s.getInputStream();byte[]buf = new byte[1024];s.close();接收服务端回复

ServerSocket服务端:

ServerSocket ss = new ServerSocket(10000);建立服务端Socket服务并监听一个端口

Socket s =ss.accept();通过accept方法获取链接的客户端对象

String ip = s.getInetAddress().getHostAddress(); 通过客户端对象获取其IP地址

InputStream in = s.getInputStream();获取客户端发送数据,获取客户端读取流对象读取该数据byte[]buf = new byte[1024]; int len = 0;System.out.println(new String(buf,0,len));

OutputStream out = s.getOutputStream();out.write("ssfdf".getBytes());回复客户端

s.close();关闭客户端释放资源

ss.close();服务端不一定要关

s.shutdownOutput();关闭客户端输出流,想到在流中加入标记-1

 

URL

URL url = new URL("http://219.141.157.4:8080/myweb/demo.html?name=haha&age=30");

url.getProtocol();协议名

url.getHost();主机名

url.getPort();端口号

url.getPath();路径

url.getFile();文件名

url.getQuery();参数信息name=haha&age=30

URL url = new URL("http://219.141.157.4:8080/myweb/demo.html");建立URL对象

URLConnection conn = url.openConnection();获取链接对象

InputStream in = conn.getInputStream();

byte[]buf = new byte[1024];

int len = in.read(buf);