1、JVM使用的字符表示：
在Java中，字符只能以一种形式存在，即Unicode；
JVM的这种约定使得一个字符分为两部分：JVM内部和OS文件系统。在JVM的内部同一使用Unicode编码，当字符从内部到外部时，就进行了编码转换。
2：public class test{
static { int x=5; } ////在第一次被载入JVM时运行，但是是局部变量，后面程序不能使用
static x,y; ////初始化为x=0,y=0; 全局变量 后面cx使用的都是这里的x
.......
}
j = j++///等价于 t=j; j=j+1; j=t;
:3：数据类型转换：
·简单数据类型转换：类型由低到高分别是（byte,short,char）--int--long--float--double
·自动类型转换（低到高）（如char转为int时，会自动转换为对应的ASCII值 char c; int i=c;）
·强制类型转换：（高到低）（同一级的不能自动转换，可以使用强制类型转换）
·包装类过度类型转换：java共有6个包装类，Boolean、Character、Integer、Long、Float、Double；；
（ double d; Double D1=new Double(d); int i=D1.intValue(); ）
4：代码笔记
a：short s=1; s=s+1; ///此代码错误（s+1是int，不能直接复制给s）
Short s=1; s+=1; ///此代码正确
b：int A=5； System.out.println( “value =” + ( (A<5) ? 10.2 : 9 )); ///结果是9.0
c: char x=’x’; int i=10;
flase ? i : x ///此出结果为120 ，因为i是int型的，所以x自动转为int
flase ? 10: x ///此处结果为x ，当存在常量表达式时，常量表达式可被另外一个类型，输出结果是char型
d：·if( (m!=5) && (n++=5) ){}
System.out.println(n); ///结果为5 ，因为&&（短路），m！=5已经false，所以后面的就不会执行
·if( (m!=5) & (n++=5) ){} ///结果为6 ，因为&（非短路），m！=5是false，但后面仍需计算
e：布尔型默认是flase
f：静态方法只能访问静态变量
g：IO操作中 以InputStream 或OutputStream为后缀的是字节流 ；；以Reader或Writer为后缀的是字符流。
5：异常：
Java程序中左右抛出（throw）的异常都必须从Throwable派生而来的，类Throwable有两个直接子类Error和Exception；
·常见的错误有程序进入死循环、内存泄漏，这种情况下程序运行时本身无法解决，只能通过其他程序干预。Java对应的类为Error类，Error对象有java虚拟机生成并抛弃。（java程序不做处理）。
·异常是程序执行时遇到的非正常情况或意外行为，程序运行时本身可以解决，由异常代码调整程序运行方向，程序可以继续运行。Java异常对应的类为Exception类。Java编译器要求程序必须捕获或声明所有的非运行时异常，但是对运行时异常不作处理。
异常关键字throw和throws的区别：
Throw用于方法体内部，用来抛出一个Throwable异常；
Throws用于方法体外部的方法声明部分，用来声明方法可能会抛出某些异常，
6：final、finally、finalize的区别：
Final：如果一个类被声明为final，意味着它不能再 派生出新的子类（继承），因此一个类不能既是abstract又不能是fianl。
如果将变量或者方法声明为final可以保证他们在使用中不被破坏(改变)，其初始化可以在两个地方：一是其定义出，直接赋值；；二是在构造函数中。（两者选一个） final变量不能修改，方法不能重写
Finally：as大V在异常处理是提供finally块来执行任何清除操作。
finalize：是方法名，java允许使用此方法在垃圾收集器将对象从内存中清除出去之前做要的清理工作。它是在object类中定义的，所以所有的类都继承了它。子类可以覆盖finalize()方法来整理资源或执行其他清理工作。此方法时在垃圾收集器展出对象之前对这个调用的。
7：传值还是传引用：
·对于基本类型，java是传值的副本（C++也是）
·对于对象型变量，java是传引用的副本，其实质是复制指向地址的指针，，只不过Java没有C++中的*和&表示。（与 C++不同，C++中当参数是引用类型时，传递的是真实引用而不是引用副本）
String类型是对象型变量，所以他必然是传引用副本。
对于基本类型而言，即使副本修改了，原值也不会变。而对于对象类型来说，它传的引用副本是指向自己地址的指针（这样做的好处：1：对象类型是存放在堆里的，速度相对于基本类型会慢；；2：本身比较大，采用复制对象的话浪费内存而且慢； ）
8：循环递归：把数组里面的数组合全部列出。比如1,2则输出1；2；12；21
| public class test { public static void main(String[] args) { String[] array =new String[] { "1","2","3","4" }; listAll(Arrays.asList(array),""); } private static void listAll(List candicate, String prefix) { System.out.println(prefix);
for(int i=0;i<candicate.size();i++) { List temp = new LinkedList (candicate);///每次remove更新当前temp listAll(temp, prefix + temp.remove(i)); } } } |
///第一次for循环里 remove 1 ； prefix更新为1 且第一个参数temp也会更新234 ///接着第二次到for循环后 temp=234 remove2后 prefix更新为12 且temp会变为34 ///接着prefix为123 ，123-4 ///跳出第一个递归后prefix 为124 ，124-3 ///要出第2个递归后prefix 为132 ， 132-4 ， 134,134-2 ///跳出3个递归后prefix为142,142-3， 143，143-2 ///跳出3个递归后，结束第一个最大的for循环 第一位为2
|
9：求出出现最多的字母及次数（使用Treeset ArrayList ）
| public class test { public static void main(String[] args) { String input="asnamnxsddkajsnncdsjkdbcueowncd"; new test().doString(input); } public void doString(String input) { char[] chars = input.toCharArray();///char数组 ArrayList lists = new ArrayList();///list TreeSet set = new TreeSet<>();///treeset for(int i=0 ; i<chars.length;i++) { lists.add(String.valueOf(chars[i])); set.add(String.valueOf(chars[i]));///set去重 } System.out.println(set);///不会重复 Collections.sort(lists);///排序 System.out.println(lists);///有重复
|
System.out.println(sb);///有重复已排序,且相同的都排在一起 input = sb.toString();///更新input int max = 0; String maxString=""; ArrayList maxlist = new ArrayList(); Iterator its = set.iterator(); while(its.hasNext()) { String os = (String) its.next(); int begin = input.indexOf(os);///找到该字符第一次出现的位置 int end = input.lastIndexOf(os);////最后一次出现的位置 int value = end - begin + 1;///相同的字符都连在一起所以可以直接得到数量 if(value>max) {///找到最多的字符 max = value; maxString =os; maxlist.add(os);///存入字符 }else if (value==max) { ///如果等于就存入多个字符 maxlist.add(os); } } |
int index=0; for(int i=0;i<maxlist.size();i++) { if(maxlist.get(i).equals(maxString)) {///找到最大字符的位置 index=i; break; } } for(int i=index;i<maxlist.size();i++) { ///得到所有数量为最大的字符（可能存在多个） System.out.println(maxlist.get(i)+" "); } System.out.println("max:"+max); }
|
| 输出结果： |
||
10:输出有相同数字的排列组合，没有重复
| public class test { static int count=0; public static void main(String[] args) { String s = "1223"; String s2 = "1232"; int t=1&0;///=0 int index[] = new int[s.length()]; for(int i=0;i<s2.length();i++) { index[i]= s2.indexOf(s2.charAt(i));///将s2所有字符第一次出现的位置记录在index = 0121 } Pailie(s,""); }
|
public static void Pailie(String s,String p) { if(s.length()<1) {///输出符合的组合 System.out.println(p); count++; }else {//System.out.println("?"); int index[]=new int[s.length()]; for(int i=0;i<s.length();i++) { index[i]= s.indexOf(s.charAt(i)); ///将s所有字符第一次出现的位置记录在index //System.out.print(s.charAt(i));///第一次for完了后1223 第2次for完了后223 //23 3 2 22 2 231 31 1 } for(int i=0;i<s.length();i++) { if(i==index[i]) {///只有当循环数与第一次记录数相等是才度过，保证相同字符中的第一个调用 //System.out.println("ppp:"+index[i]); /0/0/0/0/1/0/2/0/0/1/0/0/0/1/0/1/0/0/1/0/2/0/0/1/0/3/0/0/0/1/0/0/1/0 Pailie(s.substring(1), p+s.substring(0,1));///递归，打印其他字符 } s=s.substring(1)+s.substring(0,1); //System.out.println(s); 3 32 2 23 232 322 2 22 22 223 2231 1 13 3 等 } } } } |
|
