标签：log 重复元素 tab set集合 主题 false 写文件 写入 extend
2016-07-23 周六
利用键盘输入的时候需要抛出异常 ，直接快捷键 ctrl + 1 ;
定义数组 int score[] = new int[4] ; 只有4个数字
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
String str = br.readLine() ;//直接输入，直接输出
score[i] = Integer.parseInt( str) ; //转换Str 为 Int
int temp = Integer.parseInt(str); //字符串变为int型
String str = new String(b); byte变字符串
Scanner scan = new Scanner(System.in) ;
冒泡排序： i=1;j=0 ;
for (int i = 1 ; i < 3 ;i++ ){
for(int j = 0 ; j< 3 ; j++){
if(score[i] < score[j]){
int temp = score[i] ;
score[i] = score[j] ;
score[j] = temp ;
}
方法的定义: public static 返回值 方法名（类型 参数 ， 类型 参数,）{
程序体 ；
（return) //可省略
}
类名定义： ArrayDemo (单词首字母大写)
方法定义： printInfo (第一个单词小写，后面的单词首字母大写 )定义的时候 char c[] = {‘‘,‘‘,‘‘,‘‘} ; 字符串都是单引号，字符都是双引号
float型的参数都是 3.2f,
使用 break 可以结束一层循环
使用 return 可以结束一个方法
方法的递归 ； return x + sum(temp) ;
栈中存放的是堆空间的地址； 中放的是名字，堆内存是实际数字
2016-07-24 周日
Java 的直接数组排序 java.util.ARRAY.sort() ;
Java 的直接复制数组 System.arraycopy(源数组，源数组开始位置，目标数组，目标数组开始位置，数组长度 ) ;
(说是复制，其实就是目标位置的数组的替换，将源数组的数字复制到目标数组的位置，目标数组的长度不变)
Java 新特性：foreach(数据类型 变量名： 数组名称) ; foreach (int x ; temp) ;
Java 新特性：可变参数：返回类型 方法名(类型... 参数) public void fun (int... arg)
例： fun(new int[]{1,1,1,1,1}); // 传递参数可以直接传递
Java的多态性：方法的重载 ； 方法名同但是参数类型和参数的个数不同 ； System.out.println 也属于重载
对象的多肽 ： 子类对象可以和父类对象进行相互转换，而且根据子类的不同，完成的功能也不同
Java的封装性：对象的属性和行为看成整体，即对象；
信息的隐蔽
private 声明的属性或者方法只能被类的内部进行访问，而不能在外部被访问；
this的使用：
this.表示当前对象，this必须发放到构造方法的首行
this调用构造方法时一定要保留一个构造方法作为出口，也就是有一个构造方法不调用this();
this.方法名() 强调是本类中的方法；
this.属性 强调是本类中的属性；
Java的继承性：拥有一般特性的事物，在基础上 派生其他；
类 ： 成员变量声明 + 方法定义：
构造方法： 在实例化的时候就可以进行赋值，而不是调用setter 和 getter 方法 //也即是说，只是一个赋值的过程，没有返回值
方法名与主类同； 不能有返回值类型声明； 不能有return语句；默认 default 类型
匿名对象：没有明确给出名称的对象；一般只使用一次，而且直接开启堆空间，不存在栈空间的索引；
new Person("zhangsan",12).tell() ;
String 本身就是一个类，但是我们一般用的String没有开辟栈空间，比较的只是堆空间的值；
一个字符串本身就是一个String的匿名对象；
“==” 比较的是开辟的空间，而不是内容；
equal() 比较内容是否一致；
String 里面indexOf本身就可以比较内容 是否相等， 他是找到内容，然后返回字符所在位置， !(indexOf("hello"))!= -1 表示找到
一个String对象内容的改变实际上是通过内存地址的更新完成的，本身的字符串内容不会变；
char[] toCharArray() ;//转换为字符数组 charAt() //特定的位置取值 String split()//按照指定的字符串分割
String subString()指定字段取值 equals(), equalsIgnoreCase()
split 和 raplaxeAll() 支持正则表达式；，返回时一个 String s[] =
indexOf : 从指定位置开始查找字符串位置，没有找到就返回 -1 ；
charAt ： 取出指定位置的字符 trim() :去掉左右的空额
length 和 length() 在数组中,length是长度，String操作中是函数，需要length() ;
引用传递： 就是将一个堆内存空间的使用权交给多个栈内存空间
接受本类的对象： public void fun(Demo d2)
2016-07-28 周四
Java的内存区域：
栈内存：保存所有对象的名称（堆地址的内存空间）
堆内存：保存每个对象的属性内容
全局变量： static类型属性
全局代码段：保存所有的方法定义
Static关键字：堆内存保存对象，可以用static共享属性
static声明属性的又称为类属性，因为类的公共属性应该由类来修改，毕竟用户不知道到底会有多少对象产生；
static String count = "ad"; Person.count = "bc";
static声明的方法又称为类方法，可以用类名调用；
public static setName(String name) ; Person.setName("lvfengtao") ;
static应用，可以查看定义了多少给 实例化对象；
System.exit(1) ; //可以直接退出程序，设置非0数字
代码块：
普通代码块：{}括起来的，直接在方法或者语句中设置的
构造代码块：直接写在类中的代码块 //只有一行代码
静态代码块：用static声明的代码块
静态代码块优于主方法执行，类中的静态代码块优先于构造块执行，且只执行一次，不管产生几个对象
构造方法私有化： private 方法名()
构造方法一旦私有化，就不能new调用，就必须从内部调用
一种是static 属性，另一种是static 方法，返回实例，通过类.方法名调用；
单例设计模式： 无论程序怎么运行，始终只有一个实例化对象存在，只要将构造方法私有，就可以对控制实例化对象的产生；
数组一定要先开辟空间，因为是引用类型
主方法的String args[] 本身就是一个类，主方法中的参数本身就是以对象数组的形式出现的；
内部类： 在类的内部在定义一个类
缺点：类由属性和方法构成，所以会破坏类结构
唯一的好处就是可以访问外部类的私有属性；
用static声明的内部类变成了外部类，但是不能访问非static声明的外部类属性
在外部访问内部类
外部类.内部类 内部类对象 = 外部类实例.new 内部类() ;
private 定义是在一个类里面都可以访问，所以内部类可以直接访问外部类的属性；
使用statIC声明的内部类就会成外部类，使用static声明的内部类不能访问非static声明的外部类
在方法中定义一个内部类
在方法中定义的内部类不能直接访问方法中的参数，如果发放中的参数想要被内部类访问，就必须在参数前加final关键字
2016-07-30 周六
使用构造方法的时候，一定是this.setName(name); 继承的时候是，super(age,name); Getter方法中：return school;
关于输出，最好是在类中返回String方法，然后在主类中 System.out.println(实例化对象.方法名) ；6.1 继承类(派生类)
Java只允许单继承，一个子类只允许有一个父类，允许多层继承，一个父类还有一个父类；
子类是不能调用父类的私有成员，子类可以调用父类的非私有 方法，但是不能直接调用父类的私有成员，但是可以通过setter和getter；
子类实例化对象之前，先调用父类的构造方法，后调用子类的构造方法，实际上子类的构造方法中隐藏了super()方法【超类】
子类不能拥有比父类更高级的访问权限
6.2 this 和 super 区别：
1.this 只能调用本类的属性、方法，本类中没有则父类查找 super 访问父类的方法，方法
2.this 调用本类构造， supe 调用父类构造，且放在子类首行
3.this 表示当前对象
6.4 final :完结器 ，final声明的类不能有子类，声明的方法不能被覆写，声明的变量为常量，不可以修改
final声明的变量必须全部大写； public static ，final String NAME = "Lvfengtao";
6.5 Abstract 抽象类： 抽象类是一种模板，必须被继承才能用，一个子类只能继承一个抽象类
包含一个抽象方法的类是抽象类； 抽象类和抽象方法必须由abstract声明； 抽象方法只需声明，不需要具体；
抽象类必须被继承，子类必须前部复写抽象类中的全部抽象方法 public abstract void print();
抽象方法不要使用private声明，因为必须被覆写，子类不易复写；
抽象类可以定义构造函数，所以子类实例化之前必须对父类进行实例化，也就是说先必须给打印父类的构造方法然后子类的构造方法
子类可以通过super()方法调用抽象类(父类)的构造方法,也可以在子类调用父类指定参数的构造方法
子类 extends 抽象类 implements 接口A， 接口B
6.6 接口： 特殊的类，由全局常量和公共的抽象方法组成 // 接口本身已经定义，所以不需要在写 public static fianl 和 abstract ;
由于明确规定了抽象方法是public 类，所以也不需要在写；
接口与抽象方法一样需要子类的继承 implements，一个子类可以实现多个接口，摆脱继承的单继承
全局常量，在接口里定义的时候用大写
Java允许一个抽象类实现多个接口，但是一个接口不允许继承抽象类， 允许一个接口继承多个接口
接口的继承： interface A extends B, C
interface A {
public static final String INFO =， "Lvfengtao" ==== String INFO = "Lvfengtao"
public abstract void print() ========== (public)void print()
//全局常量；
抽象方法； //必须是public方法，写与不写，Java的接口方法都是pblci
}
6.7 对象的多态性
表现： 1、方法的重载和覆写
2、对象的多态性
（向上转型：子类--> 父类 ； 父类 父类对象 = 子类实类
向下转型：父类 --> 子类，且必须说明向下转型的子类类型） 子类 子类对象 = （子类）父类实例
** 对象是Object类型，需要转型 String str = (String)obj[i];
2016-08-02 星期二
6.12 包装类； Java数据分为基本数据类型和引用数据类型,
用的最多的还是讲字符串变为数据类型（int i= Interger.parseInt("1234")）；
(字符串变为数组的时候需要抛出异常)
拆箱 和装箱： Interger i = new Interger(x); int x = i.intValue();
Integer i = 0 ;//自动封装 int x = i; //自动拆箱
7.1 异常的基本概念
Java的异常都是以类和对象的形式存在，Java的错误主要是语法和语义的错误，编译的时候没有报错，但是运行的时候也可能报错
Try() 找到错误后会跳转到 catch里面，一旦产生异常，则首先回产生一个异常类 的实例化对象，
Exception 和 Error 都是Java Throwable的异常类
通常用e.printStaceTrace()方法打印异常信息，所有的额子类的实例都可以用父类来接受，所以可以调转
7.2 throws 和 throw关键字
throws声明的方法，表示此方法不处理异常，而是调用方法去处理；
2016-08-03 星期三
9.1 多线程： 继承 Thread类【要覆写run()】或者实现Runnable类 // 都需要覆写run()方法
由于受到单继承的影响，所以一般多线
中程是通过
同时可以调用父类start()方法，实现多线程，说是调用start()方法，但是调用的却是run()方法的主题
一般重复调用start()方法回抛出异常，而且本质上调用 start0()这个方法，因为使用了native声明，所以需要依靠底层的操作系统支持
实现Runnable()方法，需要实现多线程，可以利用Thread类中设定的方法启动多线程
Thread类也是Runnable接口的子类，但是Thread并没有完全的实现Runnable接口的run() Thread 构造方法 Thread thread = new Thread(接受 Runnable的子类，设置线程名称 )
继承Thread类并不能实现资源共享，如果想要资源共享必须实现Runnable接口
避免单继承带来的局限性； 代码能与多个线程共享，代码与数据是分开的；
9.2 线程的状态： 创建 、就绪、 运行、 阻塞、 终止
getName: 取得线程名称； setName： 设置线程名称
main()本身也就是一个线程，每次Java运行都至少启动2个线程，一个main,一个垃圾回收
main()方法可能比其他方法更早执行；
public static Thread currentThread(): 返回当前执行的类
public final String getName(): 返回线程名称
public final int getPriority(): 返回优先级 1 5 10
public boolean isInterrupted(): 线程是否中断；
9.3 Thread类中有一个方法: 利用 构造函数可以直接命名线程 子类实例化以后就可以直接start
Runnable,需要 子类实例化对象，然后调用Thread调用start方法
9.6 解决资源同步问题：1、使用同步代码(Synchronized(同步对象 this)
2、同步方法
多线程 共享同一资源的时候需要同步，但是过多会产生死锁；
方法的完整定义：
public/default/private/protected final static syncronized 返回类型 方法名（参数类型 参数名称） throws EXCEPTION{ return [返回值/返回调用处]}
死锁： 同步可以保证资源共享的正确性，所谓死锁就是2个线程都在 等待彼此完成任务，造成程序停滞
2016-08-06 星期六
new String(bInput); //byte数组变为字符串 byte[] b = str.getBytes();
int i = Integer.parseInt(str); //字符串变整数 {\\d4}必须 数字出现4次
(^\\d+.?) 正则表达式匹配小数 ,? 表示小时代可以出现一次或0次
[a-zA-Z0-9]字母数字 \w 字母、数字、下划线 ^\\d{4}-\\d{2}-\\d{2}$:年与日
[abc]: 字符abc [^abc]: 除了abc之外的任意字符 \d ：数字 \D: 非数字 \w：字母、数字、下划线 \s:所有空白字符
X？：出现0次到1次 X*:出现0次，1次，多次 X+：出现1次或多次
X|Y： 先X或Y XY：先X后Y
正则表达式需要Patter和Matcher两种类完成, Patter类主要进行正则规范Matcher主要执行验证
Patter.complie("[0-9]+").matcher(str).matches();
Patter p = Patter.compile("[0-9]+");
Matcher m = p.matcher(str);
m.matches();
12.16 序列化
实现Serializable接口，还需要依靠对象输出对象和对象输入流
对象输出流(ObjectOutputStream): 实现序列化
构造方法(传入输出对象)：ObjectOutputStream(OutputStream out)
普通方法(输出对象)： writeObject(Object obj)
File file = new File("E:" + File.separator + "test.txt");
ObjectOutputStream oos = null;
OutputStream os = new FileOutputStream(file);
oos = new ObjectOutputStream(os);
oos.writeObject(new People("People",21));
oos.close();
实现Externalable接口，还需要依靠对象输出对象和对象输入流
public void readExternal(ObjectInput input) // 读取需要的 内容
{
this.name = (String)input.readObject(); //需要转换
}
public void writeExternal(ObjectOutput output) // 写入需要的 内容
{
output.writeObject(this.name);
}
transient: 声明 的关键字不可以被序列化13.1 认识类集
:动态完成对象数组操作，是动态的对象数组，是对一些实现好 的数据结构的包装，不受对象数组长度限制；
特点:对基本类集（动态数组、连接表、树）实现是高效的
框架允许不同类型的类集以相同的方式和高度
Collection: 接口，存放一组单值(集合中的每个元素都是一个对象)的最大接口，
List: Collection 子类接口，堆Collection扩充，允许内容重复
Set: Collection 子类接口，没有对Collection扩充，允许内容不重复
依靠hashCode()和equals()两个方法区别
Map； 存放一对值得最大接口，Key -- > Value
Iterator:集合的输出接口，用于输出集合中的内容，胆小
ListIterator: 可以双向输出
Enumeration: 输出指定集合的内容
SortedSet: 单值的排序接口，可以使用比较器排序
SortedMap：存放一对值得排序接口，按照key值比较
Queue: 队列接口，可以实现队列操作
Map.Entry: Map.Entry的内部接口，每个Map.Entry对象都保存这一对 key --> Value的内容，每个Map接口都保存很多Map.Entry接口实例
List<String> list = new ArrayList<String>() ;
System.out.print(list);
2016-08-07 星期日
13.1 String str[] = list.toArray(new String[]{}); //后面的{}实为初始化
indexOf() 找不到返回-1 找到显示位置
ArrayList 和 Vector区别：
ArrayList是异步处理方式，性能高，非线程安全操作类，使用Iterators
LinkedList子类和Queue接口
LinkedList表示一个链表的操作类， ListedList<> l = new ListedList<>();
poll()方法找到首字母并回删除首节点， peak() 找到首字母
Queue表示的是队列操作接口，采用FIFO方式操作，for(int i; i< list.size()+1
set：
散列存放：HashSet：
set<String/也可以是个类名> s = new HashSet<String/也可以是类名>();
System.out.println(set); //自主调用toString()方法
有序存放：TresSet 类中的每一个对象所在的类都必须实现Comparable接口才可以使用；
TreeSet自定义排序是一定要继承Comparable类，复写Comparto()方法，
public int compareTo(Person per)
但是比较器比较的时候，如果某个属性没有进行比较的指定，也会认为是同一个对象，所以应该增加按照姓名比较；
return this.name.compareTo(per.name);
去除重复元素： 主类不需要继承TreeSet,但是需要复写equals方法，编写hashCode方法
13.6 集合的输出
如果要输出Collection、Set集合中的内容，可以将其转换为对象数组输出，而List则可以直接使用get()方法输出；
常用的类集合为:
Iterator: 迭代输出(判断元素是否有内容，有就输出)
ListItarator: Iterator的子接口，专门用于输出List
Enumeration: 旧接口
2016-08-08 星期一
13.6.1
Iteration: Iterator是一个接口，直接使用Colletion定义的 itreator()实例化；同理List和Set也实现了此方法
hasNext(): 返回boolean,判断元素是否有内容，
next():输出,取出内容
ListIterator： 只能通过List实现实例化，只能输List内容
hasPrevious(): 判断是否有上一个元素
pervious(): 取出当前元素
nextIndex(): 返回下一个元素的索引
previousIndex(): 返回上一个元素的索引
set(): 替换元素
实现ListIterator接口双向输出时，如果想完成右后向前输出，则一定要先右前向后输出；
forEach: for (String str: list)//(类 对象：集合){}
13.7 Map接口
Map<K,V>:
clear(): 清空cler()
containKey(): 判断指定key是否存在
set<May.Entry><K,V> entrySet(): 将Map对象变为Set集合
Map.Entry是Map内部定义的一个接口，专门保存key->va
可以由外部通过“外部类.内部类”直接调用
Map内容是K-V形式保存，实际上K-V是把数据保存在M.E之后
Map输出数据的时候必须使用M.Entry接口
V get(OBJECT key): 根据key 取得Value
set<K> keySet(): 取得所有key
Set<String> set = map.keySet();
Collection<V> value(): 取出全部value
V put(K kye, V value): 向集合中加入元素
putAll<Map<? extends K, ? extends V>t> 一个Map集合加入到另一个
13.7.1 Map接口常用的类
HashMap： 无序存放，新的操作类，key不能重复
HashTable: 无序存放，旧类操作，key不能重复
TreeMap：有序Map集合，按key排序，不允许重复
WeakHashMap： 不再用的内容青岛湖
IdenHashM： key可以重复
Map接口的使用注意事项：
1.不能直接使用迭代输出Map内容，因为Map 存放一对值，Iterator只能输出一个
2.Map很少作为直接输出的额，只是用作查询
3.直接使用非系统类作为key
2016-08-28 星期日
//利用indexOf判断某个字符是否存在 也可以用
//replaceAll （源数字 ， 目标数字) 直接替换
//System.out.println(str.charAt(8)); 取出第8个字符
继承父类以后调用父类的构造方法：super(name, address, sex, age);
输出父类的属性： super.toString()
代理模式： 代理和真实主题均要实现接口，在代理中实现真实主题实例化(构造方法中实现)
工厂模式: 其他了均实现接口，定义一个类专门获取实例，不是构造方法获得
适配器模式：接口定义方法， 构造方法实现此接口，方法体为空，后子类继承抽象类，有选择的复写方法
观察者模式： 要被关注的继承Obserable类，调用父类方法 super.setChanged(); super.nosuper.notifyObservers() 观察着实现 Observer接口，在update类中，判断是否是一个类，输出即可
//这些接口呢都需要用到多态性，都是 接口 接口对象 = new 子类对象()，实现向上转型，转型后可以调用子类复写父类的方法
如果需要向下转型，则调用子类自己的方法，但是需要先向上转型后， instanceof 比较对象；//如果要进行字符串的拆分，利用split方法
Pattern p = Pattern.compile("[a-zA-Z]");
String s[] = p.split(str);
//如果需要正则表达式来进行字符的替换，
String str = "123231m3m123m123m123m12";
Pattern p = Pattern.compile("[a-zA-Z]");
Matcher m = p.matcher(str);
String ss = m.replaceAll("_");
、、以上方法String都有支持的 boolean matches(String regex); String[] split(); String replaceAll(String regex, s)
2016-08-30 星期三
时间类： SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
sdf.format(new Date()) ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date temp = sdf.parse(str);
字符串拆分：
String str = "<html xmlns=\"http://www.w3.org/1999/xhtml\">";
str = str.substring(str.indexOf(" ")+1, str.indexOf(">")).replaceAll("\"", " ").replaceAll("\\.", " ").replaceAll("/", " ");
字符串内输入双引号： \"
定时调度：
Timer类： 是一种线程设施，可以定时安排一个时间，与TimerTask(实现由TImer安排的一次或重复执行的某一个任务)配合使用
IO操作：
File打开文件--> 字节流制定位置-->读写--> 关闭流
FIle类：文件本身操作
boolean createNewFile();
boolean exists();
boolean isDirectory();
String[] list();
File[] listFiles();
boolean mkdir();
boolean renameTo(File dest); //已有文件重新命名
RandomAccessFile类：随机读取类（一般不用）
RandomAccessFile(File file, String mode) //file路径
RandomAccessFile(String path, String mode)//固定路径
close(): 关闭操作
void writeBytes(String s): 字符串写入文件
void writeInt(jint v)
int read(byte[] b): 将内容读取到一个byte数组
byte readByte(): 读取一个字节
int readInt(): 读取整数型
int skipBytes(int n):指针跳过多少字节
void seek(long pos): 指针位置
所有数据都是已流的方式传输或保存，分字节和字符
字节流：以byte为准，需要将字符串转为Byte数组
OutputStream
OutputStream out = new FileOutputStream(file);
OutputStream out = new FileOutputStream(file, true);追加内容
String str = "\r\nHEllo world"; 文件需换行，可以加\r\n
byte[] b = str.getBytes();
out.write(b);
out.close();
InputStream:
int avaliable(); //取得文件大小
int read();//以数字的方式读取
int read(byte[] b) ；内容读取到byte数组
InputStream input = new FileInputStream(file);
byte[] bb = new byte [(int)f.length()]
//byte[] bb = new byte[1212];
//int len = input.read(b); //取出内容到byte数组,确定输出多少
while(input.read()!=-1)
{
b[len] = (byte) temp;
len++;
}
input.close();
System.out.println(new String(b, 0, len));
一个字符2个字节；
字符流： Writer 子类： FileWriter
可以添加对象， Writer writer = new FileWriter(new File(), true);
write(String str) 字符串输出
write(char[] c) 字符数组输出
flush() 强制清空缓存
Reader 子类 FileReader
int read()
int read(char[] c): 内容读取到字符数组，返回长度
字符的输出： new String(c, 0 ,len)
读取字符串有2中方法： 直接从文件读取
for循环 读取一个字节 int len = 0；
int temp = 0; //接收每一个内容
while((temp = reader.read())!=-1)
{
c[len] = (char)temp;
len++;
}
字符流使用了缓冲区，字节流没有使用缓冲区(内存区域)；
不关闭时也将字符内容输出，可以使用Writer类的flush()方法打印流： PrintStream() 和 字符打印流()
2016-09-03 星期六
1.Serializable(Serializable)
一个类的对象要想被序列化(一个对象变为2进制，方便存储和传输)，就必须实现Serialiable接口，依靠ObjectOutputStream()和ObjectInputStream()
Java序列化的时候会产生一个序列化ID，通过JVM实现
File file = new File("F:" + File.separator + "hello.txt");
OutputStream out = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(new Person("lisi"));
ObjectInputStream ois = new ObjectInputStream()
oos.close();
InputStream input = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(input);
Object obj = ois.readObject();
ois.close();
2. Externalizable是Serializable子类，实现此接口的可以用户自己制定被序列化的内容
writeExternal(ObjectOutput ot): 指定要保存的属性信息，对象序列化时调用
readExternal(ObjectInput in): 读取被保存的信息，反序列化用
以上2个方法都是DataOutput 和 DataInput接口的子类
public Person(){};
public Person(String name)
{ this.name = name; }
//读取属性，有一个强制转换的要求
public void readExternal(ObjectInput input)
{ this.name = (String) input.readObject();}
//保存name属性
public void writeExternal(ObjectOutput output)
{ output.writeObject(this.name); }
一个类要使用Externalizable实现序列化，此类必须有一个无参构造方法，因为在反序列化的时候会默认调用无参构造实例对象
3. transient：关键字表示对象的某一个属性不希望被序列化
4. 序列化一组对象：
对象输出时只提供了writeObject(Object obj))，并没有多对象输出，所以要实现同时序列化多个对象，就可以使用对象数组操作。
因为数组属于引用类型，可以用Object类型接收
5. List Set(重复内容依靠hashCode() 和 equals()方法区别) Queue SortSet(对集合中的数据进行排序)
List:接口
add(int index, E element)
addAll(int index, Collection<? extends E> c) 添加一组元素
E get(int index)
ListIterator<E> listIterator()
E remove(int index)
E removeAll(Collection<?> arg0)
List<E> subList(int fronIndex, int toIndex)
E set(int index, E element)
toArray(): 集合变为对象
size(): 返回集合的长度
get(int index): 返回当前的位置的数字
for(int i = 0; i < allList.size(); i++)
{
System.out.print(allList.get[i] + "、");
}
LinkedLis：链表操作类
addFirst(E e );
addList(E e);
boolean offer();
E removeFirst()
Queue:先进先出
E element()： 找到表头
E peek() 找到不删除;
E pool() 找到后删除; 利用此方法先进先出输出数字
E remove() 检索并移除表头
Set：HashSet && TreeSet
HashSet:
无规律可循
TreeSet:
有规律
如果是比较对象，则需要继承Comparable接口，实现CompareTo()方法
class Person implements Comparable<Person>//接口处定义泛型类型
public int compareTo(Person per) {
if ( this.age > per.age)
{
return 1;
}
else if (this.age < per.age)
{
return -1;
}
else
{
return 0;
}
比较器操作时如果某个实现没有进行比较，则默认为是一个对象
如果实现了HashSet,则所有的重复对象也会继续出现，就需要复写Object类的equals()方法和hashCode()方法，一个对象编码表示一个对象
SortedSet: TreeSet继承SortedSet
SortedSet<String> set = new TreeSet<String>();
first(); last();
SortedSet<E> headSet(E element):开始到指定位置
SortedSet<E> tailSet(E element):指定到最后
//可以用get()方法输出数字
Iterator:
Iterator iter = list.iterator();
ListIterator:
由前向后： hasNext() && next()
有后向前： 利用hasPrevious()方法由前向后判断，用previous取出元素
set() 和 add() 可以更改和添加元素
foreach输出：
for (类 对象： 集合) {}; for（String str: all)
Map：HashMap && TreeMap
put(Object key， Object obj): 添加数据
get(): 根据key值取得value的值
Map<String, String> map = new HashMap<String, String>();
Set<String> keys = map.keySet();
Iteration key = keys.iterator();
while(key.hasNext())
{
String str = key.next();
System.out.println(map.get(str）);//根据key 取值
}
map.get（iter.next()）
containKey(): 判断指定的key是否存在
keySet(): 将一个Map中的key变为Set集合，然后利用Iterator输出
values(): 返回Collection，注意定义泛型类型
Collection<String> col = map.values();
Iteration valus = col.iterator;
while(values.hasNext()){};
Map接口注意事项：
1. 不能直接使用迭代输出Map中的全部内容，因为Map存放的是一对值，Iterate只能每次找到一个值，如果非要迭代输出，则必须：
1> Map实例通过entrySet()方法变为Set接口对象
2> 通过Set接口实例化Iterator、
3> Iterator迭代输出，每一个ie内容都是Map.Entry的对象
4> 通过Map.Entry进行 key --> value分离
(Map中的每对数据都是通过Map.Entry保存的，所以也是Map.Entry输出)
Map<String ,String> map = null;
map = new HashMap<String, String>();
map.put("04122077", "吕峰涛");
map.put("04122076", "吕峰");
` Set<Map.Entry<String, String>> set = map.entrySet();
Iterator<Map.Entry<String, String>> iter = set.iterator();
while(iter.hasNext())
{
Map.Entry<String, String> me = iter.next();
System.out.print( me.getKey() + "--> " + me.getValue() + "\t");
}
SortedMap: 排序接口，实现此类都是排序的子类，例如TreeMap
Comparator<? super K> comparator();
K firstKey(); K lastKey();
SortedMap<k, V> subMap(K fromKey, K endKey)
SortedMap<K, V> tailMap<K fromKey): 返回大于指定key的部分集合
Collection:
addAll(): 为一个集合增加内容 Collection.addAll("ARRAY", "BufferedReader");
reserve():
binarySearch(): 返回内容位置
sort(); 排序
swap(): 交换我ie之
Stack: 先进先出
push: 进站
pop: 出战
int search(Object o): 在战中查找
Properties:
new Property().setProperty("key", "value");
store(OutputStream out, String comment, String encoding);
list(PrintStream out):
loadFromXML(InputStream in):
storeToXML(OutputStream out)
2016-09-05 星期一
1. Class类方法
Class<?> forName(String Name): 传入完整"包.类", 实例化Class对象
c1 = Class.forName("com.huawei.ftl.X");
System.out.println("类名称： " + c1.getName());
也可以通过类.class或者对象.getClass()实力化Class类
实例化后可以通过newInstance()实例化对象，注意转换类型
per = (Person) c.newInstance();
（以上注意一点，就是类中必须由无参构造方法）
Construtor[] getConstructor: 得到类中所有的构造方法
Field[] getDeclaredFields(): 得到继承来的类
Class[] getInte
2016-09-10 星期六 JavaWeb
HTML注释语句： <!-注释语言->
1. JS的事件处理： body (onLoad()="start()" onUnload()="stop()" onClick="fun()")
onSubmint():事件在提交之前先验证
onCHange(): 变化
文本处理： var value = document.form.content.value;
//精确到具体的name值，然后取值，否则为空
2.3.3Window对象
window.location: 定位到对应网页
window.open: 打开网页设置
HTML： 表达式完成交互的收到，表单元素写在《form>里面
JavaScript是基于对象的语言，function是函数，又返回值直接返回return即可。
3.1 XML： 可扩展性标志语言，实现数据交换，系统配置，内容管理。
XML语言是以<? ?> 开始和结束的
version：
encoding：编码
standalone: 是否独立运行， XML声导固定格式
<?xml-stylesheet type="text/css" href = "attri.css"?>
<![CADATA[里面的内容不解析]]>
3.2 XML解析：SAX && DOM(文档对象模型)
4个重要的额借口：
Document：整个XML文档，根节点
Node：每一个Node代表一个节点
NodeList：节点的集合
NamedNodeMap：一组节点和其唯一名称对应关系，属性节点
NodeList getElementByTagNsme();取指定节点名
Element createElement(String tagName):创建指定名节点
Dom4J：利用工具来读写文件
Document doc = DocumentHelper.createDocument();
Element addresslist = doc.addElement("addresslist");
Element linkman = addresslist.addElement("linkman");
Element name = linkman.addElement("name");
name.setText("吕峰涛");
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("GBK");
2016-09-11 星期日
1.创建目录--> WEB_INFO--> 复制WEBapps/ROOT/web.xml到虚拟目录下
Tomcat修改端口：conf/server.xml
虚拟目录：复制web.xml
<content path="/mldn" docBase="虚拟目录地址"/>
修改conf/web.xml listings的false修改为true;
2xx:请求成功
3xx:重定向
403：禁止
404：找不到文件
500：服务器内部错误
Tomcat是个Web容器
2.JSP学习
JSP的命名采用小写，且最终都是以*.class完成
request.getParameter()方法接受输入内容。
2016-09-11
1. JavaBean；一个类只包含属性，setter,getter方法
POJO: 简单的Java对象
VO： 专门传递值
TO： 传递对象
2. 数据库操作：
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, tid);
(注意顺序，一定是先执行语句，然后设置变量)
2016-09-18
1.抽象类的使用： Person per = new Student("lvfengtao", 12o, 99.9f);
抽象类中定义抽象方法为public， 不用写方法体 public abstract void say();即可；
2.工厂模式中在工厂类中定义了一个静态方法来获取接口的实例；
public static Fruit getInstance(String name)
3.代理模式； Network net = new Proxy(new Real());
}
2016-10-02 星期日
1. 使用Dom4J 生成XML文件，XML主要是用于数据交换
Document创建一个DOC文档，一个文档只有一个根节点
Element添加元素，
OutputFormat完成格式化，设置为中文格式。
XMLWriter完成数据的写入
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(
new FileOutputStream(
"G:" + File.separator + "new2016.xml"), format );
writer.write(doc);
writer.close();2. JS操作XML
JS点击显示文字：
document.getElementById("info").innerHTML = "<h2>www.MLDNJAVA.cn</h2>" ;
JSP注释：
1.<!--注释内容--> 显示注释客户端可以看见
2.<%--注释内容--%>; /* */ // 隐式注释
Scriptlet：3种方式
1.<% %> : 定义局部变量
<%!%>： 全局变量，类，方法
<%=%>: 输出一个变量
2.标签：<jsp:scriptlet> 代码块 </jsp:scriptlet>
Page: langua="Java" contentType="text/html" pageEncoding="GBK"
必须是text/html 因为conf/web.xml写了这个
2.错误页面显示：
<%@ page isErrorPage = "true"%> isErrorPage (注意大小写)
<%@ page errorPage="error.jsp"%>
属于服务器端的跳转
Include：包含指令：
1.静态包含： <%@ include file= "" %>
2.动态包含：<jsp:include>:自动区分页面静态还是动态
<jsp:include page = "{包含文件路径 | <%=表达式%>}" flush = "true/false"/>
<jsp:param name="参数名称" value="参数内容"/>
</jsp:include>
静态是先包含后处理，动态是先处理后包含
跳转： <jsp:forward page = {""}>
2016-10-04 星期二 JSP
中文问题：
HTML：<meta http-equiv="Content-Type" content="text/html;
charset= utf-8 "/>
REQUEST：如果获取返回的值，可以设置
request.setCharacterEncoding("utf-8");
1.JSP内置对象 (9个，out, request, session(保存用户信息), application(所有用户的共享信息), response, pageContext(JSP页面容器))
4个属性：page(一个页面保存，调整失效),
request(只在一次 请求保持),
session(再一次会话范围内，任何跳转都行，新开浏览器失效),
application(服务器保持)
公共方法： setAttribute(), getAttribute(), removeAttribute(),
2.
page:
pageContext.setAttribute("name", "吕锋涛");
String name = (String)pageContext.getAttribute("name");
取得属性后要记得想下转型
HTTPServletRequest && ServerletRequest
request： 表示跳转后属性继续保存，换成超链接之后失效，一次情况下服务器只会给予回应一次
getParametervalues(String name)： 取得客户端发来的一组请求
String method = request.getMethod();
String ip = request.getRemoteAddr();
String path = request.getServletPath();
String contextPath = request.getContextPath();
Enumeration enu = request.getHeaderNames();
角色验证
HTTPServletResponse && ServerletResponse
response:对客户的的请求回应(HTML跳转 && sendRedirectict)
addCookie(Cookie cookie)
setHeader(String name, String value) //
response.setHeader("refresh",2) 2秒刷新一次
response.setHeader("refresh",2; URL="hello.html") 2秒刷新后跳转页面，客户端跳转
<META HTTP-EQUIV="refresh" CONTNT="3";URL="hello.html">
sendRedirectict(String location)客户端调整
<jsp:forward> && sendRedirectict:
JSP是服务器段跳转，跳抓后地址不变，客户端跳转会导致地址变化
服务器端跳转时立刻的，客户端是执行万页面后跳转
操作Cookie：让服务器端的技术保存在客户端，火灾客户端执行数据处理，提高了网页的速率，减少了服务器的运载，安全性差。
javax.servlet.http.HttpSession
session： 一次设置，与设置页面相关就保存属性，可以通过超链接。新打开浏览器失效
主要用于登陆和注销操作，每一个session对象都表示不同的访问用户
getId(),
getCreation():
getLastAccessedTime():
isNew():
invalidate()://让session失效
Enumeration getAttributeNames():
获取用户时间：getCurrentTIme()；
登陆程序：通过sessio保存方法； 使用Cookie保存信息； 通过表单隐藏域保存信息； 通过地址重写保存信息
application:保存属性到服务器
getRealPath():
getContextPath():取得当前虚拟路径名称
配置虚拟目录：<Context path="/mldn" docBase="D:/mldn">
总结一下：
1. request.setCharacterEncoding("GBK"); 设置为中文格式。
<meta http-equiv="Content-Type" content="text/html;
charset= utf-8 "/>
2. this.getServletContext().getRealPath("/")； 后去虚拟目录对应的真是目录
request.getContextPath(); //获取虚拟目录对应目录
3. PrintStream ps = new PrintStream(new FileOutputStream(file)); 设置输出流 ，输出到文件
ps.println(content);
ps.close();
//但凡IO操作必然涉及异常处理以及IO流的关闭
4. Scanner scanner = new Scanner(new FileInputStream(file)); 不明到底有多少的时候用StringBuffer;
scanner.useDelimiter("\n");
StringBuffer buf = new StringBuffer();
5. response.setHeader("refresh", "2;URL=login.jsp"); 定时跳转
<META HTTP-EQUIV="refresh" CONTENT="3";URL="request_demo_02.html">HTML定时跳转
session.invalidate(); 用户失效
session.getAttribute("userid")； 获取属性
session.getId(); 和Cookie一样
6. Cookie c[] = request.getCookies(); 至少1个
<%=c[i].getName()%> ---> <%=c[i].getValue()%>
**inst： getParametervalues用星号其区别；
7. <jsp:param name="uname" value="<%=name%>"/> 传递参数：
get && post区别：
get:提交后的内容会显示在地址栏，post不会
pageContext: response等设置的都可以在pageContext完成。
pageContext.forward("hello.jsp"?info="hell0"); 传递参数可以直接传递
String info = pageContext.getRequest().getParameter("info");
config的配置需要在web.xml文件中配置
2016-10-05 星期三 JavaBean；
1. JavaBean；一个类只包含属性，setter,getter方法
POJO: 简单的Java对象
VO： 专门传递值
TO： 传递对象，远程传输时必须继承Serialization
所有的类放入一个包，声明为public class, 属性封装，至少有一个无参构造方法
<jsp:useBean id = "sim" scope="page" class="com.huawei.ftl.SimpleBean"/>
<jsp:setProperty property="*" name="sim"/> name是实例化对象名称，pro="*" 自动匹配
2. 三目运算： return value == null?"":value;
3. MVC:
Model:完成独立的业务操作，JAVABEAN
Control ：负责所有的用户请求，判断是否合法，根据请求类型调用JavaBean，显示给View
View：接受Servlet传递的内容，调研JavaBean显示给用户
RequDispatcher(): request属性传递内容2016-10-09 星期日 小雨
1. JSTL1.2标准库开发
c: 核心开发库
sql:查询数据库操作
xml：XML数据
fn: 函数操作
H&N：fmt.tld 格式化数据
2. c:out :输出属性
c：set: 设置属性
<jsp:useBean id="login" class = "com.huawei.mvc.servlet.LoginServlet" scope = "request"/>
<% request.setAttribute("simple", login); %>
<c:set var = "world" value = "hello world" target = "${simple}" property = "content" />
var:属性名称 value: 属性内容 scope: 保存范围 target:存储的目标属性 property:制定target属性
c: remove : 删除指定属性
c: catch:异常处理
c: choose:多条件判断，可以结合c:when c:otherwise
<c:choose>
<c:when test="${num==20}">
<h3>输入的nuam的值为： 20</h3>
</c:when>
</c:choose>
c: foreach :输出数组，集合
<c:forEach items="${ref}" var = "m">
${m}
</c:forEach>
注意items里写的是一个集合，一个变量，要用${}表示
c: url : 根据路径和参数生成一个新的URL
c: redirect: 客户端跳转
c: if :
<c:if test="${10 > 1}" var = "res" scope = "request">
test制定比较大小内容， var保存判断结果
c:forToken: 拆分数组
c:import 可以讲其他页面导入进来，类似<jsp include>
2016-10-10 Struts开发
1. Struts 中的Action相当于Servlet
ActionForm == JavaBean
所有的输入从ActionForm取得,Servlet中由request取得
Action 中完成跳转，需要在Struts-config中配置，每个Action配置也给跳转路径
2016-10-22 星期六
1. <script language = "javascript"> js 是小写
用onsubmit()方法的时候一定是 return validate(this)
JS 中 判断值得方法是：
DOM4J XMLWriter 和SAXReader解读
标签：log 重复元素 tab set集合 主题 false 写文件 写入 extend
原文地址：https://www.cnblogs.com/ftl1012/p/9332858.html
