java基础总结1

1、在进行字符串逆转时可以采用StringBuffer对象的reverse方法调用。

2、String对象s转化为StringBuffer对象sb的申明：

   StringBuffer sb = new StringBuffer(s);

3、java语言获取键盘输入的数据

    Scanner scan = new Scanner(System.in);
        int number = scan.next();

4、java中判断某个字符串是否含有某个子串可以采用：

(1)、s.indexOf(str)!= -1;

(2)、s.contains(str) == true;

另外还可以采用方法

matches、regionMatches、

5、Eclipse代码自动对齐快捷键ctrl+shift+f。

6、往StringBuffer对象的最开始插入数据采用 s.insert(0,c)。

7、String类的substring()方法总结

     substring(int i)---该函数返回字符串从第i个位置到结尾的字符串

 8、正则表达式"\\s+"是将一个字符串以空格(空格可以有1个到多个)分隔

9、进行求解首次出现次数最多的字符时如下代码很值得推荐：

	public static String MostNumber(String s){
		String maxStr = null;
		int maxLen = 0;
		String first;
		
		while(s.length() > 0){
			int length = s.length();
			first = s.substring(0, 1);
			s = s.replaceAll(first, "");
			if(maxLen < length - s.length()){
				maxLen = length - s.length();
				maxStr = first;
			}
		}		
		return maxStr +"," + maxLen;
	}

10、Collections.sort(List) 方法将list中的对象按照从小到大的顺序进行排序

11、list的add()方法是添加数据，remove()方法进行删除数据。

 12、java实现将一个数字进行逆转的方法：

       

while(number >= 1){
    System.out.println(number % 10);
    number = number / 10;
}

 13、判断一个字符串中是否全部是小写字母：

	private static boolean whetherLowerCase(String str){
		boolean b = true;
		for(int i = 0 ; i < str.length() ; i++){
			if(str.charAt(i) < 'a' || str.charAt(i) > 'z'){
				b = false;
				break;
			}			
		}		
		return b;
	}

 14、以前写一串数字是否是回文时。我还经常去判断这串数字的长度是奇数还是偶数，现在终于做出来了。只需要两个下标，第一个下标i从第一个数开始往后走，第二个下标j从最后一个数往前走，直到i == j的时候截止。如果中间每次比较的两个数都相等，则这串数字是回文，否则不是。

15、for循环的第二个语句的值是一个boolean类型。

16、字符和字符串的大小写转换。如下是小写转换为大写：

如果是String类的，用toUpperCase()方法就OK: str=str.toUpperCase;
如果是char,也简单：   c=(char)(c-32);

如下是要将大写转换为小写：

如果是String类的，用toUpperCase()方法就OK: str=str.toLowerCase;
如果是char,也简单：   c=(char)(c+32);

17、判断一个数是否为素数，只用循环从2到 该数的平方根 就可以了。

18、判断一个字符是大写字母还是小写字母，还是数字。例如

char c；

Character.isLowerCase(c);

Character.isUpperCase(c);

Character.isDigit(c);

19、正则表达式：

String str ;

str = str.replaceAll("\\D", ",");  //将str中的所有非数字以逗号分隔

20、按顺序打印Map对象中的数据：

for(Map.Entry<String , Integer> entry : charMap.entrySet()){

    System.out.println(entry.getKey() + "," + entry.getValue());

}

21、获取Map对象中的第一个数据：

Iterator it = charMap.entrySet().iterator();

Map.Entry entry = (Map.Entry)it.next();

22、判断一个数是否是2的N次方：

if(num == 1 ||  (num &(num -1)) == 0){

    return true;

}

else{

    return false;

}

23、判断一个字符串中的左右括号是否匹配:

Stack类中的empty函数：

如果栈为空就返回true，否则返回false。

	private static boolean checkBracket(String str){
		Stack<Character> s = new Stack<Character>();
		for(int i = 0 ; i < str.length() ; i++){
			if(str.charAt(i) == '('){
				s.push(str.charAt(i));
			}
			else if(str.charAt(i) == ')' && s.size() > 0){
				s.pop();
			}
		}
		return s.empty();
	}

 24、像要将拼音转换为数字的题目，一般都会用到HashMap。

25、统计一行字符串中每个字符或者单词出现的次数，可以采用的方法有如下两种：

第一种方式：

int len;
		while(string.length() > 0){
			first = string.substring(0, 1);
			len = string.length();
			string = string.replaceAll(first, "");
			charMap.put(first, len - string.length());
		}

 针对replaceAll(String regex, String str2)方法而言，第一个参数是一个正则表达式。正则表达式中有很多特殊字符，比如'?' , '.', '+',等等这样的字符，如果是真的需要替换这样的字符的话需要用到转义，也就是在第一个参数表达式中要这样写"\\?", "\\.", "\\+"。

第二种方式：

	StringTokenizer st = new StringTokenizer(str,",. ");
		Map<String,Integer> map = new HashMap<String, Integer>();
		while (st.hasMoreTokens()) {
           String letter = st.nextToken();
           int count;
           if (map.get(letter) == null) {
                  count = 1;
              } else {
                  count = map.get(letter).intValue() + 1;
              }
              map.put(letter,count);
          }

 26、buffer输入

String str=null;   
	    BufferedReader buf = new BufferedReader(new InputStreamReader(System.in)); 	   
	    try {
	        str = buf.readLine();
	    } catch (IOException e1) {	 
	        e1.printStackTrace();
	    }

 27、StringTokenizer类：

StringTokenizer st = new StringTokenizer(str,",. ");//string tokenizer 类允许应用程序将字符串分解为标记
while (st.hasMoreTokens()) {  // 测试此 tokenizer 的字符串中是否还有更多的可用标记
    String letter = st.nextToken(); //返回此 string tokenizer 的下一个标记
}

 28、求两个字符串的最长公共(LCS)子串：

总算大概明白了求两个字符串的最长子串的算法：

如下的算法思想如下：

当字符匹配的时候，不是简单的给相应元素赋上1，而是赋上其左上角元素的值加一。

我们用两个标记变量来标记矩阵中值最大的元素的位置，在矩阵生成的过程中来判断

当前生成的元素的值是不是最大的，据此来改变标记变量的值，那么到矩阵完成的时

候，最长匹配子串的位置和长度就已经出来了。

 

public class Test {
	public static void main(String[] args) {  
        char[] left = "li lei".toCharArray();  
        char[] right = "li li".toCharArray();  
        char [] result = delLGS(left, right);  
        String strResult="";  
        for(int index = 0;index<result.length;index++){  
            strResult = strResult+ result[index]+"";  
        }  
        System.out.println(strResult);  
        
        String s = "asdfjasldfjas";
        System.out.println(s.contains("sdfj"));
    }  
  
    public static char[] delLGS(char[] left, char[] right) {  
        int lenLeft = left.length;  
        int lenRight = right.length;  
        int c[][] = new int[lenLeft][lenRight];  
        char[] p;  
        int start, end, len, i, j = 0;  
  
        end = len = 0;  
  
        for (i = 0; i < lenLeft; i++) {  
            for (j = lenRight - 1; j >= 0; j--) {  
                if (left[i] == right[j])// 元素相等时  
                {  
                    if (i == 0 || j == 0)  
                        c[i][j] = 1;  
                    else {  
                        c[i][j] = c[i - 1][j - 1] + 1;  
                    }  
                } else  
                    c[i][j] = 0;  
  
                if (c[i][j] > len) {  
                    len = c[i][j];  
                    end = j;  
                }  
            }  
        }  
  
        start = end - len + 1;  
        p = new char[len];  
        for (i = start; i <= end; i++)  
        {  
            p[i - start] = right[i];  
        }         
        return p;  
    } 
}

 29、Arrays.sort(ch[])方法对数组ch中的字符按照ASCII码值进行从小到大进行排序。

30、去掉一个字符串中所有重复的字符

 String str = "abcdeabcdeabcdeaaaaaadddddceeeeabcccccccacadaeec";
        str = str.replaceAll("(?s)(.)(?=.*\\1)", "");
        System.out.println(str);

 对上面的语句进行解析：

(?s)   开启单行模式 DOTALL  让. 号匹配任意字符
(.) 任意字符  并捕获在第一组
(?=.*\1)  这是断言, 表示后面内容将是 任意个字符加上第一组所捕获的内容

这样子,如果这整个式子匹配到,表示,第一个捕获组内容在字符串中,至少出现两次，替换为 "" 空串.

进行 全局替换后， 整个字符串所出现的字符将不重复。

31、替换某行字符串中的某个单词：

	public static void main(String[] args) {
			   
		    String text = "Replaced Exact String Replace In Java";
		   
		    text = text.replaceAll("\\bReplace\\b", "abcd");
		   
		    System.out.println(text);
		  }

 32、正则表达式的相关语法和使用：

http://www.360doc.com/content/10/0611/18/11586_32554860.shtml

33、贪心算法解决找零钱方案：

源链接如下： http://hi.baidu.com/cntjdavid/item/9142a438640b1fc21b969612

代码如下：

public class Test {
	public static void main(String[] args)  
	{  
	        int m[]={25,10,5,1};  
	        int n=99;  
	        int[] num=new int[m.length];  
	        num=zhaoqian(m,n);  
	        System.out.println(n+"的找钱方案：");  
	        for(int i=0;i<m.length;i++)  
	        System.out.println(num[i]+"枚"+m[i]+"面值");  
	}  
	public static int[] zhaoqian(int m[],int n)  
	{  
	        int k=m.length;  
	        int[] num=new int[k];  
	        for(int i=0;i<k;i++)  
	        {  
	                num[i]=n/m[i];  
	                n=n%m[i];  
	        }  
	        return num;  
	}   
}

34、String类的split(String regex) 方法：

其中regex是一个正则表达式。

String str = "bcbcbcb,bcb,";
	String[] subStr = str.split("," , -1);
System.out.println(subStr.length());

 上面的结果返回3。subStr数组的值分别为“bcbcbcb” ， “bcb”， “”

 35、判断某一年是否是闰年：

	private static boolean isLeapYear(int year){
		boolean b = false;
		if(year % 4 == 0 && year % 100 != 0 && year % 400 == 0){
			b = true;
		}		
		return b;
	}

 36、java判断一个char类型的值ch是否是整数，采用的方式是：

Character.isDigit(ch);

 37、大端序和小端序：

        Big-Endian和Little-Endian的定义如下：
1) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
2) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
举一个例子，比如数字0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址
0x12  |  0x34  |  0x56  |  0x78

2)小端模式：

低地址 ------------------> 高地址
0x78  |  0x56  |  0x34  |  0x12

可见，大端模式和字符串的存储模式类似。

 

 38、十进制和十六进制之间的转换：

// 十进制转化为十六进制，结果为C8。
Integer.toHexString(200);
// 十六进制转化为十进制，结果140。
Integer.parseInt("8C",16);