Java基础关键知识点（1）

亦凉 2022-09-10 04:19 144阅读 0赞

# 在JAVA中如何跳出当前的多重嵌套循环？ #

package com.study.Cyclic;
    
    import org.junit.Test;
    
    /** * @Description 在JAVA中如何跳出当前的多重嵌套循环？ * @Classname ForDemo * @Date 2021/9/4 15:21 * @Created by 折腾的小飞 */
    public class ForDemo { 
        /* 在外层定义标号 XX: 在里层循环体使用带有标号的break语句 */
        @Test
        public void test1() { 
            System.out.println("测试标号");
            xx:
    // System.out.println("测试标号"); 好像编号下面不能加其他语句
            for (int i = 0; i < 10; i++) { 
                for (int j = 0; j < 10; j++) { 
                    System.out.println("i:" + i + "," + "j:" + j);
                    if (j == 5) { 
                        break xx;
                    }
                }
            }
            System.out.println("测试标号");
        }
    
        /* 通过变量控制 查找元素 */
        @Test
        public void test2() { 
            int arr[][] = { { 1, 2, 3}, { 4, 5, 6, 7}, { 9}};
            boolean found = false;
            for (int i = 0; i < arr.length && !found; i++) { 
                for (int j = 0; j < arr[i].length; j++) { 
                    System.out.println("i=" + i + ",j=" + j);
                    if (arr[i][j] == 5) { 
                        found = true;
                        break;
                    }
                }
            }
    
        }
    }

![在这里插入图片描述][372568fa17e74435add8d4bd623bec99.png]  
![在这里插入图片描述][2153974c0829465ab8f31e1dd8783123.png]

# switch语句能否作用在`byte`上，能否作用在`long`上，能否作用在`String`上? #

package com.study.JavaBase;
    
    import org.junit.Test;
    
    /** * @Description switch语句能否作用在byte上，能否作用在long上，能否作用在String上? * @Classname switchDemo * @Date 2021/9/4 15:38 * @Created by 折腾的小飞 */
    public class switchDemo { 
        @Test
        public void test1(){ 
            Long numLong=234L;
            /* Incompatible types. Found: 'java.lang.Long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum' 参数可以是Byte和String,不能是Long */
            switch (numLong){ 
                case 234L:
                    System.out.println(true);
                    break;
                default:
                    System.out.println(false);
            }
        }
    }

# short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错? #

package com.study.JavaBase;
    
    import org.junit.Test;
    
    /** * @Description short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错? * @Classname AssigningOperatorDemo * @Date 2021/9/4 16:23 * @Created by 折腾的小飞 */
    public class AssigningOperatorDemo { 
        @Test
        public void test(){ 
            short s1=1;
            System.out.println(s1 = (short) (s1 + 1)); // 提示提升类型为int，int赋给short需要强制转型
            System.out.println(s1 += 1); // += 会进行特殊处理
        }
    }

# `Math.round(11.5)`等于多少? `Math.round(-11.5)`等于多少? #

package com.study.JavaBase;
    
    import org.junit.Test;
    
    /** * @Description Math.round(11.5)等于多少? Math.round(-11.5)等于多少? * @Classname RoundDemo * @Date 2021/9/4 16:28 * @Created by 折腾的小飞 */
    public class RoundDemo { 
        @Test
        public void test(){ 
            System.out.println(Math.floor(11.5)); //向下取整
            System.out.println(Math.floor(-11.5)); //向下取整
            System.out.println(Math.ceil(11.5)); // 向上取整
            System.out.println(Math.ceil(-11.5)); // 向上取整
    
            System.out.println(Math.round(11.5)); // 11.5+0.5 向下取整 12
            System.out.println(Math.round(-11.5)); // -11.5+0.5 向下取整 -11
        }
    }

![在这里插入图片描述][731532b672bb47db8e13f2315978e2c5.png]

# `String` 和`StringBuffer`的区别 #

JAVA平台提供了两个类：`String`和`StringBuffer`，它们可以储存和操作字符串，即包含多个字符的字符数据。  
这个String类提供了数值不可改变的字符串。  
StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。  
典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。

# 如何把一段逗号分割的字符串转换成一个数组? #

package com.study.JavaBase;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    import java.util.StringTokenizer;
    
    /** * @Description 如何把一段逗号分割的字符串转换成一个数组? * @Classname SegmentationStrDemo * @Date 2021/9/4 16:38 * @Created by 折腾的小飞 */
    public class SegmentationStrDemo { 
        static String str = "我是，一个,不开森的,程序员"; // 有中文和英文逗号
        static String strEng = "我是 ,一个 ,不开森的 ,程序员"; // 英文逗号
    
        @Test
        public void testRegx() { 
            String[] split = str.split("[\\,\\，]+"); // 正则匹配出现中文和英文符号，出现1次或多次
            System.out.println(split.length);
            for (String s : split) { 
                System.out.println(s);
            }
        }
    /* Java StringTokenizer 属于 java.util 包，用于分隔字符串。 StringTokenizer 构造方法： 1. StringTokenizer(String str) ：构造一个用来解析 str 的 StringTokenizer 对象。java 默认的分隔符是空格("")、制表符(\t)、换行符(\n)、回车符(\r)。 2. StringTokenizer(String str, String delim) ：构造一个用来解析 str 的 StringTokenizer 对象，并提供一个指定的分隔符。 3. StringTokenizer(String str, String delim, boolean returnDelims) ：构造一个用来解析 str 的 StringTokenizer 对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。 StringTokenizer 常用方法： 1. int countTokens()：返回nextToken方法被调用的次数。 2. boolean hasMoreTokens()：返回是否还有分隔符。 3. boolean hasMoreElements()：判断枚举 （Enumeration） 对象中是否还有数据。 4. String nextToken()：返回从当前位置到下一个分隔符的字符串。 5. Object nextElement()：返回枚举 （Enumeration） 对象的下一个元素。 6. String nextToken(String delim)：与 4 类似，以指定的分隔符返回结果。 */
        @Test
        public void StringTokenizerDemo() { 
            StringTokenizer tokenizer = new StringTokenizer(strEng," ,");
            while (tokenizer.hasMoreTokens()){ 
                System.out.println(tokenizer.nextToken());
            }
        }
    }

![在这里插入图片描述][b275b113bb76450da7fbadc81c3957dc.png]  
![在这里插入图片描述][be7fff4e8b004ad4b41822b9845bbcef.png]  
感觉还是`split`好用一些，可以匹配任意字符  
`StringTokenizer`可以匹配连续的多个字符

# try \{\}里有一个return语句，那么紧跟在这个try后的finally \{\}里的code会不会被执行，什么时候被执行，在return前还是后? #

也许你的答案是在return之前，但往更细地说，我的答案是`在return中间执行`，请看下面程序代码的运行结果：

public  class Test { 
    	public static void main(String[] args) { 
    		System.out.println(new Test().test());;
    	}
    	static int test()
    	{ 
    		int x = 1;
    		try{ 
    			return x;
    		}
    		finally{ 
    			++x;
    		}
    	}
    }
    /* ---------执行结果 --------- 1 return x; 在程序执行到这一步的时候，这里return 1; 这个返回路径就确定了 但是呢，它发现后面还有finally，所以继续执行finally的内容，++x； x为2 再次回到以前的返回路径，继续走 return 1; */

public class smallT
    { 
    	public static void main (String args[])
    	{ 
    		smallT t = new smallT();
    		int b = t.get();
    		System.out.println(b);
    	}
    	
    	public int get()
    	{ 
    		try
    		{ 
    			return 1;
    		}
    		finally
    		{ 
    			return 2;
    		}
    	}
    }
    /* 返回的结果是2。我可以通过下面一个例子程序来帮助我解释这个答案， 从下面例子的运行结果中可以发现， try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行， 所以，返回的结果是2。 return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中， 此时函数并不是马上返回，它要执行finally语句后才真正开始返回。 */

public  class Test { 
    	public static void main(String[] args) { 
    		System.out.println(new Test().test());;
    	}
    
    	int test()
    	{ 
    		try{ 
    			return func1();
    		}
    		finally{ 
    			return func2();
    		}
    	}
    	
    	int func1()
    	{ 
    		System.out.println("func1");
    		return 1;
    	}
    
    	int func2()
    { 
    		System.out.println("func2");
    		return 2;
    	}	
    }
    /* -----------执行结果----------------- func1 func2 2 */

**结论**：`finally中的代码比return 和break语句后执行`

[372568fa17e74435add8d4bd623bec99.png]: /images/20220829/592d79db802347a5bf2907826c1f5c62.png
[2153974c0829465ab8f31e1dd8783123.png]: /images/20220829/0d373cf48cc54292812bbe0257098199.png
[731532b672bb47db8e13f2315978e2c5.png]: /images/20220829/2a3f687ab7734d57a55818256ea2649e.png
[b275b113bb76450da7fbadc81c3957dc.png]: /images/20220829/f87845c0eae04e7fafa85fa3a2d8fef2.png
[be7fff4e8b004ad4b41822b9845bbcef.png]: /images/20220829/b356c5de5f1949e1a673b9a612e24c98.png