Java复习篇一

从天津转站北京，爬到中关村到直立行走
Java复习篇一
（白天忙碌的工作，晚上回来写写程序那种感觉近乎美妙）
将之前所学温习一遍，从理论再到示例，在短时间内能提高编程感觉，再迈向黑马训练营！

1.Java的编译原理和环境变量的设置
public class FirstJava {

public static void main(String[] args){
String name="xinglefly";
int age=22;
String address="tianjin";
System.out.println("My name is: "+name);
System.out.println("My age is: "+age);
System.out.println("My address is: "+address);

}
}

在开始——》运行——》cmd—>java -version—>—javac FirstJava.java（编译成一种中间的字节码（byte code）生成.class文件）—>java FirstJava（运行）
在面试中有很多时候都会有这道题。我之前都无法解释出来为什么会有这个。

包含环境变量的设置了(建议都是大写JAVA_HOME,PATH,CLASSPATH)
CLASSPATH：java加载的类库，最主要的就是tools.jar和jvm.jar，方式.:%java_home%/bin,
变量为什么要设置成【.】感到有点困惑，基本上CLASSPATH变量的默认值就是现在的目录，也就是【.】，如果你的CLASSPATH变量中只有【.】的话，是可以省略这个环境变量。
那什么时候用到CLASSPATH变量呢？
Java把class分为三类，第一类是Bootstrap classes(java2patform所内置的类库，放在jre/lib目录下的rt.jar（lib包中的压缩文件）和il8n(internationalization的缩写国际化)),第二类是Extension classes,最后一类是Userclass.
Path:java的可执行程序，javac.exe，java.exe
java源代码——>编译——>java字节码——>JVM——操作系统——硬件（java结构）

Javax不是与生俱来的，都是扩展包

2.java中提到的位运算和负数运算
怎样判断位运算
短路的：&& ，||
不短路的：& ， |
//怎样判断逻辑用算或者是位用算
a&b 是boolean 是逻辑用算
是整数的话就是位用算

//switch(temp)  有四种类型：byte,short,int ,char,枚举
位运算符（bitwise）4种（只能用在整数类型中）
And 【&】 (所有数据为boolean) 通俗理解两个相同的为真
Or【|】 一个为true都为真
Xor【^】 一个true和false为真，两个为true或者为false都为假
求补【~】  （1当ture,0当false）
以下数据为例：
0000 0001
0000 0011
————————
& 0000 0001=1

| 0000 0011=3

^ 0000 0010=2

~ 1111 1100=-4


说到这里，就需要了解一下负数的计算，我是在看《java2全方位学习》一书时经常提到这负数的运算，所以就找资料。
原码：将一个整数，转换成二进制，就是其原码。如单字节的5的原码为：0000 0101；-5的原码为1000 0101。
反码：正数的反码就是其原码；负数的反码是将原码中，除符号位以外，每一位取反。如单字节的5的反码为：0000 0101；-5的原码为1111 1010。
补码：正数的补码就是其原码；负数的反码+1就是补码。如单字节的5的补码为：0000 0101；-5的原码为1111 1011。
在计算机中，正数是直接用原码表示的，如单字节5，在计算机中就表示为：0000 0101。负数用补码表示，如单字节-5，在计算机中表示为1111 1011。
这儿就有一个问题，为什么在计算机中，负数用补码表示呢？为什么不直接用原码表示？如单字节-5：1000 0101。
我想从软件上考虑，原因有两个：
1、表示范围
拿单字节整数来说，无符号型，其表示范围是[0,255]，总共表示了256个数据。有符号型，其表示范围是[-128,127]。
先看无符号，0表示为0000 0000，255表示为1111 1111，刚好满足了要求，可以表示256个数据。
再看有符号的，若是用原码表示，0表示为0000 000。因为咱们有符号，所以应该也有个负0（虽然它还是0）：1000 0000。
那我们看看这样还能够满足我们的要求，表示256个数据么？
正数，没问题，127是0111 1111，1是0000 0001，当然其它的应该也没有问题。
负数呢，-1是1000 0001，那么把负号去掉，最大的数是111 1111，也就是127，所以负数中最小能表示的数据是-127。
这样似乎不太对劲，该如何去表示-128？貌似直接用原码无法表示，而我们却有两个0。
如果我们把其中的一个0指定为-128，不行么？这也是一个想法，不过有两个问题：一是它与-127的跨度过大；二是在用硬件进行运算时不方便。
所以，计算机中，负数是采用补码表示。如单字节-1，原码为1000 0001，反码为1111 1110，补码为1111 1111，计算机中的单字节-1就表示为1111 1111。
单字节-127，原码是1111 1111，反码1000 0000，补码是1000 0001，计算机中单字节-127表示为1000 0001。
单字节-128，原码貌似表示不出来，除了符号为，最大的数只能是127了，其在计算机中的表示为1000 0000。
2、大小的习惯（个人观点）
也可以从数据大小上来理解。还是以单字节数据为例。有符号数中，正数的范围是[1,127]，最大的是127，不考虑符号为，其表示为111 1111；最小的是1，不考虑符号为，其表示为000 0001。
负数中，最大的是-1，我们就用111 1111表示其数值部分。后面的数据依次减1。减到000 0001的时候，我们用它标示了-127。再减去1，就变成000 0000了。还好我们有符号为，所以有两个0。把其中带符号的0拿过来，表示-128，刚好可以满足表示范围。
以上只是从软件的角度进行了分析，当然，从硬件的角度出发，负数使用补码表示也是有其原因的，毕竟计算机中，最终实现运算的还是硬件。主要原因有三：
1、负数的补码，与其对应正数的补码之间的转换可以用同一种方法----求补运算完成，简化硬件。
如：
原码 反码 补码
-127 -〉127 1000 0001 -〉 0111 1110 -〉 0111 1111
127 -〉-127 0111 1111 -〉 1000 0000 -〉 1000 0001
-128 -〉128 1000 0000 -〉 0111 1111 -〉 1000 0000
128 -〉-128 1000 0000 -〉 0111 1111 -〉 1000 0000
可以发现，负数和正数求补的方法是一样的。
2、可以将减法变为加法，省去了减法器。
在计算机中，我们可以看到，对其求补，得到的结果是其数值对应的负数。同样，负数也是如此。
运算中，减去一个数，等于加上它的相反数，这个小学就学过了。既然其补码就是其相反数，我们加上其补码不就可以了。
如：A - 127，
也就相当于：A + (-127)，
又因为负数是以补码的形式保存的，也就是负数的真值是补码，既然这样，当我们要减一个数时，直接把其补码拿过来，加一下，就OK了，我们也可以放心地跟减法说拜拜了！
当然这也涉及到类型转换的问题，如单字节128，其原码是1000 0000，其补码也是1000 0000。这样我们+128，或者-128，都是拿1000 0000过来相加，这样不混乱掉了？还好，各个编程语言的编辑器对有类型转换相关的限制。
如：（假设常量都是单字节）
1 + 128， 真值的运算是 0000 0001 + 1000 0000 ，如果你将结果赋值给一个单字节有符号正数，编辑器会提示你超出了表示范围。因为运算的两个数据是无符号的，其结果也是无符号的129，而有符号单字节变量最大可以表示的是127。
1 - 128，真知的运算是 0000 0001 + 1000 0000 ，因为-128是有符号，其运算结果也是有符号，1000 0001，刚好是-127在计算机中的真值。
3、无符号及带符号的加法运算可以用同一电路完成。
有符号和无符号的加减，其实都是把它们的真值拿过来相加。真值，也就是一个数值在计算机中的二进制表示。正数的真值就是其原码，负数的真值是其补码。所以，有符号和无符号由编译器控制，计算机要做的补过是把两个真值拿过来相加。

谈谈公司笔试题中涉及的知识
J2SE缩写和基本套件（我当时就傻眼了,下来立马整理。现在看都有点不太理解)
JavaTM2 platform standand Edition(J2SE)，J2EE除了J2SE中基本API库，包含编写服务器端、分布式应用程序，事物处理等企业应用所需的API库。
J2ME是java平台套件中最小的一个消费性电子产品和嵌入式系统用于手机，PDA等。
垃圾回收（Garbage collection）是由JVM帮助我们程序对内存进行动态管理。
异常处理（Exception）更安全，更稳定，程序随机应变的能力增强。使程序不至于突发的错造成运行中断或是死机的情况。

真正的JAVA
面向对象：以数据抽象为导向
面向过程： 以业务逻辑抽象为导向

（1）。抽象要抽象什么？
宏观的：对象 1.数据 （用我现实的数据）
2.业务逻辑
以什么抽象作为导向（对象导向，过程导向）
类： 静态属性；动态方法。
类的封装 该私有的私有，该公开的公开
类的属性一般是私有
类的方法 该私有的私有，该公开的公开
数据原型类：生成对象的过程 1）分配对象空间
   2）给属性赋初始值
调用构造方法
类和对象
数据——》类型——》类
（1）静态特征：属性
（2）动态行为：方法。

抽象类：abstract修饰的类
一旦某个类中包含有抽象方法，那这个类必须定义成抽象类。反之，如果一个类不包含任何抽象方法，这个类可以定义成抽象类。
抽象类不能实例化，但能定义一个引用。
Abstract和final不能同时使用。
Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。
Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。

接口：1）接口中所有方法都是抽象方法，不需要用abstract声明
  2）final static 修饰的（不管你是否这样写）
  3）没有构造方法，也不能生成对象
    4）类与接口之间代码复用关系叫实现，而不叫继承一个类可以实现多个接口。
常量；2）规范
接口不需要像类需要构造函数，它只是一种规范，用途的定义声明。
类除了方法之外，还可以又类和实例属性。
Final+static限定词一起使用，可节省内存空间。

子类——> 父类（继承）
类  ——> 接口（实现）
接口——>接口 （多继承）
接口—X—>类   (错)
遵循多态定理，在接口也可以定义一个引用，子类对象中依然使用。
JAVA中不允许多继承，一个类有且只有一个父类（单继承）。
JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

多态:
多态的前提，将子类对象当做父类对象来看，我们可以把子类对象当做父类对象来看，但是我们一旦这样做了，就只能用父类的方法。
当我们把子类对象当做父类对象来看是，如果子类覆盖了父类的方法，则调用该方法时，该调用是子类覆盖后的方法。
多态的体现：父类的引用指向了自己子类的对象
多态的前提：必须是类与类之间有关系，要么继承，要么实现，存在覆盖。
多态的好处：多态的出现大大的提高程序的扩展性
多态的应用
多态的弊端：提过了扩展性，但是只能使用父类的引用访问父类中的成员。
对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。
在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。
注意：编译时类型一定要为运行时类型的父类（或者同类型）。
对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。
程序的运行时，动态类型判定。运行时调用运行时类型，即它调用覆盖后的方法。
动态绑定：
在编译时期：参阅引用型变量所属类中是否有调用方法。如果有，编译通过，不过没有编译失败。
在运行时：参阅对象所属的类中是否有调用方法。
成员函数在多态调用时，编译看左边（主观认为），运行看右边（客观存在）。
静态绑定：静态成员函数特点，无论编译和运行，都参考左边。

主观认为（编译时类型） Animal ai = new Bird();客观存在（运行时类型）
对象名instance of 类名（接口名）
关系运算符：instanceof
a  instanceof Animal;(这个式子的结果是一个布尔表达式)
a为对象变量，Animal是类名。
上面语句是判定a是否可以贴Animal标签。如果可以贴则返回true，否则返回false。
在上面的题目中： a instanceof Animal返回 True，
                 a instanceof Dog也返回 True，
instanceof用于判定是否将前面的对象变量赋值后边的类名。
Instanceof一般用于在强制类型转换之前判定变量是否可以强制转换。
以上就是按照它的运行时来判断的


类与类之间的模块与模块之间的复杂度，高内聚低耦合，接口编程的好处独立完成某项工作。
降低系统的耦合度
将标准制定者和标准的是吸纳者分离，JDBC（接口）
尽量简单JDBC的驱动（实现类）
基于接口的编程（基于抽象的编程）


面向对象主要针对面向过程。
面向过程的基本单元是函数。

比较面向过程的思想和面向对象的思想：
面向过程的思想：由过程、步骤、函数组成，以过程为核心；
面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。

在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能 。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：
class  Student{
  代码
}
注意类名中单词的首字母大写。
实例变量：定义在类中但在任何方法之外。（New出来的均有初值）
局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。这是局部变量和实例变量的一大区别。
实例变量的对象赋值为null。
局部变量不允许范围内定义两个同名变量。实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。
实例变量和局部变量允许命名冲突。


类方法中的一类特殊方法：构造方法。
构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。
注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。
构造方法没有返回值。格式为：public 方法名。
构造方法的方法名与类名相同。
构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。
在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

用类来生成对象的语句：
Student  s=new Student()。
第一个Student表示这是用Student类进行定义。“Student()”表示调用一个无参数的构造方法。
如果()中有参数，则系统构造对象的过程中调用有参的方法。
此时S称为一个对象变量。
 Student  s的存储区域存放的是地址：一个对象在硬盘上占有一个连续地址，首地址赋予s空间。
S称为对象Student的引用。
注意：在对象变量中存放的是引用（地址）；在简单变量中存放的是数值。


如果没有特殊情况，属性一定私有，方法该公开的公开。
如果不指明谁调用方法，则默认为this。
区分实例变量和局部变量时一定要写this。


Super()表示调用父类的构造方法。
Super()也和this一样必须放在第一行。
This()用于调用本类的构造方法。
如果没有定义构造方法，那么就会调用父类的无参构造方法，即super()。


static:静态成员{属性，方法}
实例属性
静态（类）属性
static 属性和实例属性的差别：
static属性在整个类中只有一份值。实例属性有多少个对象就有多少个值。
static属性在类加载的时候实例化。实例属性在未生成对象的时候才被实例化。
对static属性的访问直接通过类名去访问：Animal.count(),可以在没有生成任何对象之前就访问到。
静态方法中只能访问本类中的静态成员。
final:修饰类，属性，方法，局部变量

Object类中的11种方法。
Clone:（我现在都还未能透彻的理解，把文档写下来，以后会明白的）
浅复制：把原对象的基本属性复制，把对象的方法引用。
String name;
int age;
深复制：所有的都复制



String类（对象池即鱼池）
(1).对象池（9个，8个基本类型Wrap+String）
String s1 = "hehe";(首先在对象池里面找)
String s2 = "hehe";
String s3= new String("name");(生成新的对象)
System.out.println(s1==s2);true (在同一个对象池里)
System.out.println(s1==s3);false （一定意味着s3是新的字符串对象）

直接给出字符串，字符串对象在对象池里面拿，如果有直接拿，如果没有就创建。
对数面试题有：String s1 = new String("hehe")；创建了几个对象？
在J2SE中2个。
在J2ME中1个，没有对像池概念。
不变模式：
一个字符串对象创建后它的值就不能在被改变，直到当垃圾回收时。
String s1 = "hello";（它的值是没改变的）
s1=s1+",world";(两个字符串对象连接)改变的是他的指向，没改变值
如果频繁改值，会产生垃圾，不建议使用。
   StringBuffer字符串缓冲

equals(比较两个值是不是相等)
5大原则：1)反射性：x.equals(x),return true;
2)对称性：x,y非空，x.equals(y);y.equals(x);return true;
3)传递性：x,y,z非空，同上写法
4）一致性：
5）非空性：x.equals(null) return false;

toString
一般输出值或对象时调用的Object中的toString（）方法。
字符串类型可以和任何类型的值做连接运算，结果是新的字符串值。

5）拆装包装类（Wrapper）
提供8种包装类，Integer,Character,Byte,Boolean,Long,Floagt,Double，String类的包装类
Static int parseInt(String s)字符串的解析
Static int praseInt(String s,int radi x);传值("123"，8)以进制方式解释左边的字符串

以String类来说，也适用于8种基本类。
对象池可以移植
Integer i = 5;
Integer i = new Integer(5);
不变模式可以改变方向
Integer i = 5; 自动封箱
i=i+3;


实例化9个对像池
主方法参数：public static void main(String [] args)
为虚拟机传值。


我现在看着都有点晕，等以后磨合吧
new Integer(5); (常用)
Integer.valueof(5);
Integer i=5;(直接封箱，解箱)
i.intValue(); (常用)
int a = new Integer(5);
new Integer("123");
Integer.Valueof("123");
i.toString();
Integer.ParseInt("");
Integer.toString();

package Javamodel;
/**
* hash code (java 建议使用的方法)
* 它是一种数据结构，是散列码，混列码
* 当覆盖equlas方法时，也请将hash code 方法一并覆盖。
* hash code方法的覆盖方式是将用于equals方法中的属性，取其wrapper类的hash code,然后将它返回。
* 如果有好几属性用于equals方法中，则将这几个属性的Wrapper类的hash code做 ^ 处理，做运算后返回。
* @author xinglefly
* @version 1
*/
class MyObject implements Cloneable{
int date;
public MyObject(int i) {
date = i;
}

public boolean equals(Object obj){
if(obj!=null && (obj instanceof MyObject))
if(this.date == ((MyObject)obj).date)
return true;
return false;
}

public int hashCode(){
return (new Integer(date).hashCode());
}

//覆盖object类中的clone方法
public Object clone(){
try{
return super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
return null;
}
}

//覆盖Object类中的toString
public String toString(){
return "hash_code implements Object,overwrite toString  "+date;
}

//finalize它是用在对象被回收之前，GC调用的方法。所以通过这个覆写方法，来确定对象有没有被回收
public void finalize(){
System.out.println("gc :"+date);
}
}

public class Hash_Code {

public static void main(String [] args){
MyObject m1 = new MyObject(1);
MyObject m3 = new MyObject(1);
MyObject m2 = new MyObject(3);
System.out.println("m1 hashcode  "+m1.hashCode());

System.out.println("m2 hashcode  "+m2.hashCode());
System.out.println("m3 hashcode  "+m3.hashCode());

System.out.println("---------clone----------");
MyObject o1 = new MyObject(4);
//MyObject o2 = o1;
MyObject o2 = (MyObject)o1.clone();
System.out.println("o1 date "+o1.date);
System.out.println("o2 date "+o2.date);

System.out.println("-----after");
o2.date=5;

System.out.println("o1 date "+o1.date);
System.out.println("o2 date "+o2.date);
System.out.println("o2  "+o2.toString());




System.out.println("---------runtime GC(garbage collection)---------");
Runtime run = Runtime.getRuntime();//java中只有一个runtime实例
System.out.println("program start");
System.out.println("Free / total memory(bytes):"+"JVM中的空闲内存量 "+run.freeMemory()+" / "+"JVM中的内存总量 "+run.totalMemory());
MyObject my1 = new MyObject(1);
MyObject my2 = new MyObject(2);
MyObject my3 = new MyObject(3);
my2 = new MyObject(4);

System.out.println("Create three myobjects……");
System.out.println("Free / total memory(bytes):"+"JVM中的空闲内存量 "+run.freeMemory()+" / "+"JVM中的内存总量 "+run.totalMemory());


my1 = null;
my2 = null;
my3 = null;
System.gc();//调用gc方法之前会去调用finalize
System.out.println("After released Myobject obj");
System.out.println("Free / total memory(bytes):"+"JVM中的空闲内存量 "+run.freeMemory()+" / "+"JVM中的内存总量 "+run.totalMemory());


}
}

String:
String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
字符串种的包含的字符数，也就是字符串长度。
Int length();获取长度
根据位置获取位置上某个字符。
Char charAt(int index);
根据字符获取字符在字符串中位置。
int indexof(int ch);返回的是ch在字符串种第一次出现的位置。
Int indexof(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
Int indexOf(String str):返回的是Str在字符串中第一次出现的位置。
Int indexOf(String str,int fromIndex):从fromIndex 指定位置开始，获取str在字符串中出现的位置。
Int lasIndexOf(int ch);
判断
2.1 字符串中是否包含某一个字串。
Boolean contains(str):
特殊之处：indexOf(str)可以索引str第一次出现位置，如果返回-1，表示str不在字符串中存在。所以，也可以用于对指定判断是否包含。
If(str.indexOf("aa")!=-1)
而且该方法即可判断，有可以获取出现的位置。
2.2 字符串中是否有内容。
Boolean isEmpty();原理就是判断长度是否为0.
2.3 字符串是否适宜指定内容开头，内容结尾。
Boolean startsWith(str);
Boolean endsWith(str);
2.5判断字符串内容是否相同，复写了object类中的equals方法。
Boolean equals(str)
2.6判断内容是否相同，并忽略大小写
Boolean equalseIgnoreCase()
转换
将字符数组转换成字符串
构造函数：String(char[])
  String(char[],offset,count);将字符数组中的一部分转成字符串
静态方法：Static String copyValueof(char[]);
  Static String copyValueof(char[] data,int offset,int count)
Static String valueof(char[]);
B.将字符转成字符数组。
C.将字符数组转换成字符串。
String(byte[])
String(byte[],offset,count);将字符数组中的一部分转成字符串。
   D.将字符串转成字节数组。
E.将基本数据类型转成字符串。
F.将基本类型转成字符串
Static String valueOf(int)
Static String valueOf(double)
替换
String replace(oldchar,newchar);
切割
String[] split(regex);
字串，获取字符串中的一部分
String subString(begin);
String subString(begin,end);
转换，去除空格，比较。
将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
将字符串两端多个空格去除
String trim();
对两个字符串惊醒自然排序的比较
Int compareTo(string);
package com.blackhorse.xinglefly;

/**
* String适用于描述字符串事物（提供多个方法对字符串进行操作）
* @author xinglefly
* @version 1
*/
public class StringTest {

public static void method_get(){

String str= "abcdeadfeef";
//长度
sop(str.length());
//根据索引获取字符串
sop(str.charAt(4));//当访问到字符串中不存在的角标时发生StringIndexOutOfBoundsException
//根据字符串取索引
sop(str.indexOf('d',2));//如果没有，返回-1
//反向索引一个字符出现的位置。
sop(str.lastIndexOf("a"));
}
public static void method_is(){
String str="ArrayDemo.java";
//判断文件名称是否是Array单词开头
sop(str.startsWith("Array"));
//判断文件名称是否是.java的文件
sop(str.endsWith(".java"));
//判断文件中是否包含demo
/**
* 判断字符串中是否包含一个字符串。
* boolean contains(str);
* 特殊之处啊：indexOf(str)；可以索引str第一次出现的位置， 如果返回-1，表示该str不存在
* if(str.indexof("aa")!=-1)该方法可以判断，可以获取出现的位置
*/
sop(str.contains("Demo"));
}

public static void method_trans(){
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr);
sop("s="+s);

//字符串转换为字符数组
String s1 = "ddfeizcvdfe";
char[] chs = s1.toCharArray();
for(int x=0;x<chs.length;x++){
sop("ch="+chs[x]);
}
}
public static void method_replace(){
String s = "hello java";
String s1 = s.replace('a', 'w');
String s3 = s.replace("java", "word");
sop("s="+s);
sop("s1="+s1);//新的字符串
sop("s3="+s3);
}
public static void method_split(){
//切割split
String s = "zhangsan,lisi,wanwu";
String[] arr = s.split(",");
for(int x=0;x<arr.length;x++){
sop(arr[x]);
}
}
public static void method_sub(){
String s = "abcdef";
sop(s.substring(2));//从开始位置到结尾。角标不存在，会出现角标越界异常
sop(s.substring(2, 4));//包含头不包含尾
}
public static void method_7(){
String s = "  Hello Java   ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());

String s1 = "a1c";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void sop(Object obj){
System.out.println(obj);
}

/**
* 1.模拟一个trim方法，去除字符串两端的空格。
* 思路：
* 1.判断字符串第一个位置是否为空格，如果是继续向下判断，直到不是空格为止。结尾处判断空格也是如此
*  2.当开始和结尾都判断到不是空格时，就是要获取的字符串
*/
private static String myTrim(String str) {
int start=0;int end=str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);

}
/**
* 2.将一个字符串进行反转。将字符串中指定部分进行反转，
* 思路：
* 1.曾经学习过对数组的元素进行反转
* 2.将字符串变成数组，对数组反转
* 3.将反转后的数组变成字符串
* 4.只要将或反转的部分的开始和结束位置作为参数传递
*/
public static String reverseString(String str,int start,int end){
char [] ch = str.toCharArray();
reverse(ch,start,end);
return new String(ch);

}

public static String reverseString(String str){
/*//字符串变为数组
char[] ch = str.toCharArray();
//反转数组
reverse(ch);
//将数组变成字符串
return new String(ch);*/
return reverseString(str,0,str.length()-1);
}
public static void reverse(char[] ch,int x,int y){
for(int start=x,end=y;start<end;start++,end--){
swap(ch,start,end);
}
}
public static void reverse(char[] ch){
for(int start=0,end=ch.length-1;start<end;start++,end--){
swap(ch,start,end);
}
}
public static void swap(char[] ch,int x,int y){
char temp = ch[x];
ch[x]=ch[y];
ch[y]=temp;
}
/**
* 3.获取一个字符串在另一个字符串中出现的次数
* 思路：1.定义一个计数器
* 2.获取kk第一次出现的位置
* 3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置
* 4.当获取不到时，计数完成。
* @param args
*/
public static int geSubCount(String str,String key){
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1){
sop("str="+str);
str = str.substring(index+key.length());
count++;
}
return count;
}
public static int geSubCount_2(String str,String key){
int count=0;
int index=0;
while((index = str.indexOf(key,index))!=-1){
sop("index="+index);
index=index+key.length();
count++;
}
return count;
}
/**
* 获取两个字符串中最大相同字串。第一个动作：将短的那个串进行长度一次递减的字串打印
* “abcwerthelloyuiodef” "cvhellobnm"
* 思路：1.将短的那个字符按照长度递减的方式取到。
* 2.将每获取到得字串去长串中判断是否包含，如果包含，已经找到。
*/
public static String getMaxSubString(String s1,String s2){
String max="",min="";
max = (s1.length()>s2.length())?s1:s2;
min = (max==s1)?s2:s1;
sop("max="+max+"....min="+min);
for(int x=0;x<min.length();x++){
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++){
String temp = min.substring(y,z);

sop(temp);
if(max.contains(temp)){//if(s1.indexOf(temp)!=-1)
return temp;
}
}
}
return "";
}
public static void main(String[] args){
// method_get();
// method_is();
// method_trans();
// method_replace();
// method_split();
// method_sub();
// method_7();
String s = "   abc dfeji   ";
// sop("("+s+")");
// s = myTrim(s);
// sop("("+s+")");

//Test2
String s1 = "  ab cd ";
sop(reverseString(s1));
sop(reverseString(s1,3,6));

String str = "abkkcdkkefkkskk";
sop("count="+geSubCount(str,"kk"));
sop("count="+geSubCount_2(str,"kk"));
sop("count===="+str.split("kk").length);//不建议使用

String str1 = "abcwerthelloyuiodef";
String str2 =  "cvhellobnm";
sop(getMaxSubString(str1,str2));
}

}



package com.blackhorse.xinglefly;

/**
* StringBuffer是字符缓冲区
* 是一个容器
* 1.而且长度是可变化的。
* 2.可以直接操作多个数据类型。
* 3.最终通过toString方法变成字符串。
*
* jdk1.5以后出现了StringBuilder
* StringBuffer是线程同步
* StringBuilder是线程不同步
*
* 升级3个因素：
* 1.提高效率
* 2.简化书写
* 3.提高安全性
* @author xinglefly
* @version 1
*/
public class SringBufferDemo {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
//存储
//StringBuffer append();将指定的数据作为参数添加到已有数据的结尾处。
//StringBuffer insert(index,数据);可以将数据插入到指定index位置。
//获取单个字符 char charAt(int index)
sb.append(23).append(true).append("sbdc");//
/*StringBuffer sb1 = sb.append(23);
sop(sb.toString());
sop(sb1.toString());*/
sop(sb.toString());

/**
* 基本数据类型+""
* 基本数据类型.toString(基本数据类型值)
* 如：Integer.toString(34);将34整数变成“34”
*
* 字符串转成基本数据类型。parse为静态
* xxx a = Xxx.parseXxx(String);
* int a = Integer.parseInt("123");
* double b = Double.parseDouble("123.12");
* boolean b = Boolean.parseBoolean("true");
*
* Integer i = new Integer("123");
* int num = i.intValue();//非静态
*
* 十进制转成其他进制
* toBinaryString();
* toHexString();
* toCoctalString();
*
* 其他进制转成十进制
* pareseInt(String,radix);
*/
//整数类型的最大值
sop("int max:"+Integer.MAX_VALUE);

//将一个字符串转成整数
int num = Integer.parseInt("123");
long x = Long.parseLong("123");

sop("num="+(num+4));
sop(Integer.toBinaryString(-6));
sop(Integer.toHexString(60));

int x1 = Integer.parseInt("3c",16);
sop("x="+x1);

}

public static void sop(String str){
System.out.println(str);
}
}

-----------------------------------------------------------
我在之前的学习中每天都看一个简短的定理
吉格勒定理
设定一个高目标就等于达到目标的一部分。
气魄大方可成大，起点高才能至高。