http://blog.csdn.net/it_man/article/details/8225477
 
 
 
 下面是参考网络资源总结的一些在Java编程中尽可能要做到的一些地方。
 
 　　1. 尽量在合适的场合使用单例
 
 　　使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：
 
 　　第一，控制资源的使用，通过线程同步来控制资源的并发访问;
 
 　　第二，控制实例的产生，以达到节约资源的目的;
 
 　　第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。
 
 　　2. 尽量避免随意使用静态变量
 
 　　要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如
 
 　　Java代码
 
 　　public class A{
 
 　　static B b = new B();
 
 　　}
 
 　　此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。
 
 　　3. 尽量避免过多过常的创建Java对象
 
 　　尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。
 
 　　4. 尽量使用final修饰符
 
 　　带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String.为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%.
 
 　　5. 尽量使用局部变量
 
 　　调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。
 
 　　6. 尽量处理好包装类型和基本类型两者的使用场所
 
 　　虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。
 
 　　在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。
 
 　　7. 慎用synchronized,尽量减小synchronize的方法
 
 　　都知道，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。synchronize方法被调用时，直接会把当前对象锁 了，在方法执行完之前其他线程无法调用当前对象的其他方法。所以synchronize的方法尽量小，并且应尽量使用方法同步代替代码块同步。
 
 　　8. 尽量使用StringBuilder和StringBuffer进行字符串连接
 
 　　这个就不多讲了。
 
 　　9. 尽量不要使用finalize方法
 
 　　实际上，将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。
 
 　　10. 尽量使用基本数据类型代替对象
 
 　　String str = "hello";
 
 　　上面这种方式会创建一个"hello"字符串，而且JVM的字符缓存池还会缓存这个字符串;
 
 　　String str = new String("hello");
 
 　　此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o
 
 　　11. 单线程应尽量使用HashMap、ArrayList
 
 　　HashTable、Vector等使用了同步机制，降低了性能。
 
 　　12. 尽量合理的创建HashMap
 
 　　当你要创建一个比较大的hashMap时，充分利用另一个构造函数
 
 　　public HashMap(int initialCapacity, float loadFactor)
 
 　　避免HashMap多次进行了hash重构，扩容是一件很耗费性能的事，在默认中initialCapacity只有16,而loadFactor是 0.75,需要多大的容量，你最好能准确的估计你所需要的最佳大小，同样的Hashtable,Vectors也是一样的道理。
 
 　　13. 尽量减少对变量的重复计算
 
 　　如
 
 　　for(int i=0;i
 
 　　应该改为
 
 　　for(int i=0,len=list.size();i
 
 　　并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。
 
 　　14. 尽量避免不必要的创建
 
 　　如
 
 　　A a = new A();
 
 　　if(i==1){list.add(a);}
 
 　　应该改为
 
 　　if(i==1){
 
 　　A a = new A();
 
 　　list.add(a);}
 
 　　15. 尽量在finally块中释放资源
 
 　　程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。
 
 　　16. 尽量使用移位来代替'a/b'的操作
 
 　　"/"是一个代价很高的操作，使用移位的操作将会更快和更有效
 
 　　如
 
 　　int num = a / 4;
 
 　　int num = a / 8;
 
 　　应该改为
 
 　　int num = a 》 2;
 
 　　int num = a 》 3;
 
 　　但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解
 
 　　17.尽量使用移位来代替'a*b'的操作
 
 　　同样的，对于'*'操作，使用移位的操作将会更快和更有效
 
 　　如
 
 　　int num = a * 4;
 
 　　int num = a * 8;
 
 　　应该改为
 
 　　int num = a 《 2;
 
 　　int num = a 《 3;
 
 　　18. 尽量确定StringBuffer的容量
 
 　　StringBuffer 的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再 丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。
 
 　　如：StringBuffer buffer = new StringBuffer(1000);
 
 　　19. 尽量早释放无用对象的引用
 
 　　大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null.
 
 　　例如：
 
 　　Java代码
 
 　　Public void test(){
 
 　　Object obj = new Object();
 
 　　……
 
 　　Obj=null;
 
 　　}
 
 　　上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：
 
 　　Java代码
 
 　　Public void test(){
 
 　　Object obj = new Object();
 
 　　……
 
 　　Obj=null;
 
 　　//执行耗时，耗内存操作;或调用耗时，耗内存的方法
 
 　　……
 
 　　}
 
 　　这时候就有必要将obj赋值为null,可以尽早的释放对Object对象的引用。
 
 　　20. 尽量避免使用二维数组
 
 　　二维数据占用的内存空间比一维数组多得多，大概10倍以上。
 
 　　21. 尽量避免使用split
 
 　　除非是必须的，否则应该避免使用split,split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需 要频繁的调用split,可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。
 
 　　22. ArrayList & LinkedList
 
 　　一 个是线性表，一个是链表，一句话，随机查询尽量使用ArrayList,ArrayList优于LinkedList,LinkedList还要移动指 针，添加删除的操作LinkedList优于ArrayList,ArrayList还要移动数据，不过这是理论性分析，事实未必如此，重要的是理解好2 者得数据结构，对症下药。
 
 　　23. 尽量使用System.arraycopy ()代替通过来循环复制数组
 
 　　System.arraycopy() 要比通过循环来复制数组快的多
 
 　　24. 尽量缓存经常使用的对象
 
 　　尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache,Oscache进行缓存，他们基本都实现了FIFO/FLU等缓存算法。
 
 　　25. 尽量避免非常大的内存分配
 
 　　有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。分配的内存块都必须是连续的，而随着堆越来越满，找到较大的连续块越来越困难。
 
 　　26. 慎用异常
 
 　　当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。
 
 　　如 果您创建一个 Exception ,就得付出代价。好在捕获异常开销不大，因此可以使用 try-catch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw 操作--尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就 抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则。
 
 　　(1)。 用Boolean.valueOf(boolean b)代替new Boolean()
 
 　　包装类的内存占用是很恐怖的，它是基本类型内存占用的N倍(N>2)，同时new一个对象也是性能的消耗。
 
 　　我们再看看JDK对于Boolean.valueOf(boolean b)的实现：
 
 　　Boolean类提供了两个常量：
 
 　　Java代码
 
 　　public static final Boolean TRUE = new Boolean(true);
 
 　　public static final Boolean FALSE = new Boolean(false);
 
 　　而valueOf(boolean b)的内部实现是：
 
 　　Java代码
 
 　　return (b ? TRUE : FALSE);
 
 　　因此用Boolean.valueOf(boolean b)代替new Boolean()既能节省空间，又能提高性能。
 
 　　(2)。 用Integer.valueOf(int i)代替new Integer()
 
 　　和Boolean类似，java开发中使用Integer封装int的场合也非常多，并且通常用int表示的数值都非常小。SUN SDK中对Integer的实例化进行了优化，Integer类缓存了-128到127这256个状态的Integer,如果使用 Integer.valueOf(int i)，传入的int范围正好在此内，就返回静态实例。这样如果我们使用Integer.valueOf代替new Integer的话也将大大降低内存的占用。
 
 　　(3)。 用StringBuffer的append方法代替"+"进行字符串相加。
 
 　　这个已经被N多人说过N次了，这个就不多说了。
 
 　　(4)。 避免过深的类层次结构和过深的方法调用。
 
 　　因为这两者都是非常占用内存的(特别是方法调用更是堆栈空间的消耗大户)。
 
 　　(5)。 变量只有在用到它的时候才定义和实例化。
 
 　　这是初学者最容易犯的错，合理的使用变量，并且只有在用到它的时候才定义和实例化，能有效的避免内存空间和执行性能上的浪费，从而提高了代码的效率。
 
 　　(6)。 避免在循环体中声明创建对象，即使该对象占用内存空间不大。
 
 　　这种情况在我们的实际应用中经常遇到，而且我们很容易犯类似的错误，例如下面的代码：
 
 　　Java代码
 
 　　for (int i = 0; i < 10000; ++i) {
 
 　　Object obj = new Object();
 
 　　System.out.println("obj= " + obj);
 
 　　}
 
 　　上面的做法会浪费较大的内存空间。正确的做法如下所示：
 
 　　Java代码
 
 　　Object obj = null;
 
 　　for (int i = 0; i < 10000; ++i) {
 
 　　obj = new Object();
 
 　　System.out.println("obj= "+ obj);
 
 　　}
 
 　　采用上面的第二种编写方式，仅在内存中保存一份对该对象的引用，而不像上面的第一种编写方式中代码会在内存中产生大量的对象引用，浪费大量的内存空间，而且增大了垃圾回收的负荷。因此在循环体中声明创建对象的编写方式应该尽量避免。
 
 　　(7)。 如果if判断中多个条件用'||'或者'&&'连接，请将出现频率最高的条件放在表达式最前面。
 
 　　这个小技巧往往能有效的提高程序的性能，尤其是当if判断放在循环体里面时，效果更明显。
 
 　　1.JVM管理两种类型的内存：堆内存(heap)，栈内存(stack)，堆内在主要用来存储程序在运行时创建或实例化的对象与变量。而栈内存则是用来存储程序代码中声明为静态(static)(或非静态)的方法。
 
 　　2.JVM中对象的生命周期，创建阶段，应用阶段，不可视阶段，不可到达阶段，可收集阶段，终结阶段，释放阶段
 
 　　3.避免在循环体中创建对象，即使该对象点用内存空间不大。
 
 　　for(int i=0;i<10000;++i){
 
 　　Object obj = new Object();
 
 　　System.out.println("obj="+obj);
 
 　　}
 
 　　应改成
 
 　　Object obj = null;
 
 　　for(int i=0;i<10000;++i){
 
 　　obj = new Object();
 
 　　System.out.println("obj="+obj);
 
 　　}
 
 　　4.软引用的主要特点是具有较强的引用功能。只有当内存不够的时候，才回收这类内存，因此在内存足够的时候，它们通常不被回收。它可以用于实现一些常用资源的缓存，实现Cache的功能
 
 　　A a = new A();
 
 　　SoftReference sr = new SoftReference(a);
 
 　　a = null;
 
 　　if(sr !=null){
 
 　　a = sr.get();
 
 　　}else{
 
 　　a = new A();
 
 　　sr = new SoftReference(a);
 
 　　}
 
 　　5.弱引用对象与Soft引用对象最大不同就在于：GC在进行回收时，需要通过算法检查是否回收Soft引用对象，而对于Weak引用对象，GC总是进行回收。
 
 　　A a = new A();
 
 　　WeakReference wr = new WeakReference(a);
 
 　　a = null;
 
 　　if(sr !=null){
 
 　　a = wr.get();
 
 　　}else{
 
 　　a = new A();
 
 　　wr = new WeakReference(a);
 
 　　}
 
 　　6.共享静态变量存储空间
 
 　　7.有时候我们为了提高系统性能，避免重复耗时的操作，希望能够重用一些创建完成的对象，利用对象池实现。类似JDBC连接池。
 
 　　8.瞬间值，序列化对象大变量时，如果此大变量又没有用途，则使用transient声明，不序列化此变量。同时网络传输中也不传输。
 
 　　9.不要提前创建对象
 
 　　void f(){
 
 　　int i;
 
 　　A a = new A();
 
 　　if(…){
 
 　　a.showMessage();
 
 　　}
 
 　　}
 
 　　改成
 
 　　void f(){
 
 　　int i;
 
 　　A a = null;
 
 　　if(…){
 
 　　//用到时才实例化
 
 　　a = new A();
 
 　　a.showMessage();
 
 　　}
 
 　　}
 
 　　10 .(1)最基本的建议就是尽早释放无用对象的引用
 
 　　A a = new A();
 
 　　a = null; //当使用对象a之后主动将其设置为空
 
 　　(2)尽量少用finalize函数。
 
 　　(3) 如果需要使用经常用到的图片展，可以使用软引用。
 
 　　(4) 注意集合数据类型，包括数组，树等数据，这些数据结构对GC来说，回收更为复杂，
 
 　　(5) 尽量避免在类的默认构造器中创建，初始化大量的对象，防止在调用其自类的构造器时造成不必要的内存资源浪费。
 
 　　(6) 尽量避免强制系统做垃圾内存回收。
 
 　　(7) 尽量避免显式申请数组空间。
 
 　　(8) 尽量在合适的场景下使用对象池技术以提高系统性能，缩减系统内存开销。
 
 　　11.当做数组拷贝操作时，采用System.arraycopy()方法完成拷贝操作要比采用循环的办法完成数组拷贝操作效率高
 
 　　12. 尽量避免在循环体中调用方法，因为方法调用是比较昂贵的。
 
 　　13. 尽量避免在循环体中使用try-catch 块，最好在循环体外使用try--catch块以提高系统性能。
 
 　　14. 在多重循环中，如果有可能，尽量将最长的循环放在最内层，最短的循环放在最外层，以减少循环层间的变换次数。
 
 　　15. 在需要线程安全的情况下，使用List list = Collections.synchronizedList(new ArrayList());
 
 　　16. 如果预知长度，就设置ArrayList的长度。
 
 　　17. ArrayList 与 LinkedList 选择，熟悉底层的实现原理，选择适当的容器。
 
 　　18. 字符串累加采用StringBuffer.
 
 　　19. 系统I/O优化，采用缓冲和压缩技术。优化性能。
 
 　　20. 避免在类在构造器的初始化其他类
 
 　　21 尽量避免在构造中对静态变量做赋值操作
 
 　　22. 不要在类的构造器中创建类的实例
 
 　　23. 组合优化继承
 
 　　24. 最好通过Class.forname() 动态的装载类
 
 　　25. JSP优化，采用out 对象中的print方法代替println()方法
 
 　　26 .采用ServletOutputStream 对象代替JSPWriter对象
 
 　　27. 采用适当的值初始化out 对象缓冲区的大小
 
 　　28. 尽量采用forward()方法重定向新的JSP
 
 　　29. 利用线程池技术处理客户请求
 
 　　30.Servlet优化
 
 　　(1) 通过init()方法来缓存一些静态数据以提高应用性能。
 
 　　(2) 用print() 方法取代println()方法。
 
 　　(3) 用ServletOutputStream 取代 PrintWriter.
 
 　　(4) 尽量缩小同步代码数量
 
 　　31. 改善Servlet应用性能的方法
 
 　　(1)不要使用SingleThreadModel
 
 　　(2)使用线程池ThreadPool
 
 　　32. EJB优化
 
 　　实体EJB:
 
 　　(1)实体EJB中常用数据缓存与释放
 
 　　(2)采用延迟加载的方式装载关联数据
 
 　　(3)尽可能地应用CMP类型实体EJB
 
 　　(4)直接采用JDBC技术处理大型数据
 
 　　33. 优化JDBC连接
 
 　　(1)设置合适的预取行值
 
 　　(2)采用连接池技术
 
 　　(3)全合理应用事务
 
 　　(4)选择合适的事务隔离层与及时关闭连接对象
 
 　　34. PreparedStatemetn只编译解析一次，而Statement每次都编译解析。
 
 　　35. 尽可能地做批处理更新
 
 　　36. 通过采用合适的getXXX方法提高系统性能
 
 　　37. 采用设计模式。
 

循环
 
while循环
 
while循环
 语法：
 while(循环条件){
 循环语句;
 }
 
                循环的好处：
                1、代码不冗余
                2、结构简洁
                3、代码复用
                4、后期维护成本比较低
                编写循环：
                1、确定计数
                2、每次让计数累增
                3、仔细斟酌循环条件。
                
            var i = 0;
        while(i < 10){
            document.write("hi world<br/>");
            i++;
        }
 
for循环
 
语法：
 for(表达式1; 表达式2; 表达式3){
 循环语句;
 }
 
            break     终止当前循环
            continue  跳过这次循环
 
函数
 
无参数无返回值的函数：
 
    声明函数：
            语法： function 函数名(){
                    函数体;
                    }
            调用函数：
                函数名();
            *使程序变得简短而清晰
            * 有利于程序维护
            * 可以提高程序开发效率
            * 提高了代码的重用性（复用性）
 
形参:形式上的参数。函数声明的时候未知的值叫做形参。
 

 实参：实际传入的参数。函数调用的时候传入的值叫做实参
 

 传参：用实参给形参赋值。
 
封装函数
 
无参数无返回值的函数
 
有参数无返回值的函数
 
封装函数的时候，函数的形参一般是函数中不确定的值。
 
有参数有返回值的函数
 
return后面跟什么，函数的值就是什么；

 函数在运行过程中，如果遇到return，会终止当前函数
 
arguments
 
是任何一个函数内部都有的一个内置对象，理解成变量就行了。

 arguments[下标] 取值

 arguments.length 输出当前传入的实参个数
 
作用域
 
作用域：就是起作用的范围。或者说有效范围。
 
局部变量
 局部变量就是定义在函数内部的变量，这个变量只能在函数内部使用，即作用域范围只是函数内部，另外，形参也是局部变量。
全局变量
 全局变量就是定义在函数外部的变量，这个变量在任何函数中都有效，即作用域范围是当前文件的任何地方。
 
注意：定义变量时省略var是不安全的，不过是合法的，不写var的时候会被解释是全局变量
 
递归调用
 
函数还可以自己调用自己，称为递归调用。
 
方法:
 
1.首先去找临界值，即无需计算，获得的值。
 2. 找这一次和上一次的关系
 3. 假设当前函数已经可以使用，调用自身计算上一次

Java流程控制语句
 

 
 
本博文将对JAVA中组成各种结构的控制语句进行重点介绍，主要内容是区别于C/C++中的流程控制语句的重点解析。
 

 
 
1、顺序语句
 

 顺序结构中的语句可分为：表达式语句、空语句和复合语句三大类。
 
注：
 
（1）、空语句主要用来作为空循环体，其语法格式如下：
 

；	//其实就是一个分号
 
执行一个空语句，就是将控制转到该语句的结束点。这样，如果空语句是可以到达的，则空语句的结束点也是可以到达的。
 
（2）、复合语句又称为语句块，若语句块是空的，则控制转到语句块的结束点。
 
 

 
 
2、if条件语句
 

 
 
Java中的条件语句与C/C++中一致，并没有太大的区别。
 
示例代码：
 
 
 
/********************************************************
 * "if条件语句"示例代码
 * 功能：输入三个数，输出最大值
 */

import java.util.Scanner;
public class Program {
	public static void main(String [] args) {
		int num1,num2,num3,max;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入第一个数：");
		num1=input.nextInt();
		System.out.println("请输入第二个数：");
		num2=input.nextInt();
		System.out.println("请输入第三个数：");
		num3=input.nextInt();
		max=num1;
		if(num2>max)
			max=num2;
		if (num3>max)
			max=num3;
		System.out.println("max="+max);
		input.close();
	}
}

 
 

 
 

 
3、switch条件语句
 
if else语句可以用来描述一个“二岔路口”，而switch可用于“多岔路口”的情况。
 
Switch语句是多分支选择语句，常用来根据表达式的值选择要执行的语句，其基本语法形式如下：
 
 
<pre name="code" class="java">switch （表达式）
{
case 值1：
语句块1；
break;
case 值2：
语句块2；
break;
case 值3：
语句块3；
break;
……
case 值n：
语句块n；
break;
}
 
 
 
其中，switch表示开关，case表示情况，default表示默认，break表示停止，它们都是JAVA的关键字。
 
 
/********************************************************
 * "switch语句实战演练"——根据出生日期判断星座*/

import java.util.Scanner;
public class Program {
	public static void main(String [] args) {
		System.out.println("请输入您的出生日期（如0123表示1月23日）：");
		Scanner sc=new Scanner(System.in);
		int monthday=sc.nextInt();
		int month=monthday/100;
		int day=monthday%100;
		String xingzuo="";	//保存字符串
		switch (month) {
			case 1:
				xingzuo=day<21?"摩羯座":"水瓶座";
				break;
			case 2:
				xingzuo=day<20?"水瓶座":"双鱼座";
				break;
			case 3:
				xingzuo=day<21?"双鱼座":"白羊座";
				break;
			case 4:
				xingzuo=day<21?"白羊座":"金牛座";
				break;
			case 5:
				xingzuo=day<22?"金牛座":"双子座";
				break;
			case 6:
				xingzuo=day<22?"双子座":"巨蟹座";
				break;
			case 7:
				xingzuo=day<23?"狮子座":"狮子座";
				break;
			case 8:
				xingzuo=day<24?"摩羯座":"处女座";
				break;
			case 9:
				xingzuo=day<24?"处女座":"天秤座";
				break;
			case 10:
				xingzuo=day<24?"天秤座":"天蝎座";
				break;
			case 11:
				xingzuo=day<23?"天蝎座":"射手座";
				break;
			case 12:
				xingzuo=day<22?"射手座":"摩羯座";
				break;
			default:
				break;
		}
		System.out.println("您的星座是"+xingzuo);
	}
}

 
 

 
 

 
4、循环语句
 
JAVA中采用的循环语句与C中的循环语句比较相似，主要有while/do-while/for和foreach。
 

 
 
4.1、while语句
 
while的语法形式如下：
 
 
<pre name="code" class="java">while （表达式）
{
语句块；
}
 
 

 
4.2、do-while语句
 
do-while语句会先执行循环体再判断条件表达式，其语法形式如下：
 

do {
语句块；
}while(条件表达式)；

 注：先做后判断
 

 
 
4.3、for语句
 
 
for语句适合于语句块重复执行预定次数的循环，其语法结构如下：
 

for（表达式1；表达式2；表达式3）{
语句块；
}
 
注：for语句分为表达式1或2或3为空的三种情况，无论缺少哪个部分的表达式，都可以在程序的其他位置补充，从而保持for循环语句的完整性，使循环得以正常进行。
 

 
 
 
4.4、foreach语句
 
 
foreach语句是for语句的特殊简化版本，但是foreach语句不能完全取代for语句，然而，foreach语句都可以改写为for语句版本。需要注意的是foreach并不是一个关键字，只是习惯上将这种特殊的for语句称为foreach语句。
 
foreach语句在遍历数组、集合方面，为开发者提供了极大地方便，其语法格式如下：
 

for（类型 变量名：集合）{
语句块；
}
示例代码
 

/********************************************************
 * "foreach循环语句"的使用示例及代码*/

public class Program {
	public static void main(String [] args) {
		String[] fruits = {"苹果","橘子","香蕉","西瓜","梨子","其他"};
		System.out.println("热销的水果有：");
		for(String fruit:fruits){
			System.out.println(fruit+"、");
		}
	}
}


 

 
 
4.5、实战——九九乘法口诀表
 
 
代码示例如下：
 
 

/*
 * "实战——九九乘法口诀表"*/

public class Program {
	public static void main(String [] args) {
		System.out.println("九九乘法口诀表：");
		for (int i=1;i<=9;i++){
			for(int j=1;j<=i;j++){
				System.out.print(j+"*"+i+"="+j*i+"\t");	
			}
//			注意print与println的区别
			System.out.print("\n");	
//			System.out.println();
		}
	}
}


 

 
 

 
5、跳转语句
 

 
 
严格地说，跳转语句不属于流程控制语句，但是它可以帮助程序员更加精确地控制整个流程，例如在遇到死循环时使用跳转结构来结束循环。
 
JAVA提供了与其他语言相同的跳转结构控制语句，包括：return，break和continue。
 

 
 
5.1、“return语句、break语句、continue语句”的区别与联系
 
return语句用于终止程序的执行或退出方法，并把控制权返回该方法的调用者。如果这个方法带有返回类型，则return语句就必须返回这个类型的值，若无，则可以使用没有表达式的return语句。
 
break语句使用在循环语句或者条件语句中，用于终止一条循环语句，导致控制流程跳转到循环语句的下一个语句。
 
continue语句表示退出当前循环而执行下一次的循环，适用于循环语句和switch语句。它与break的区别在于：break语句将退出整个循环语句，而continue语句仅仅退出当前循环，继续执行下一次的循环。
 

/********************************************************
 * "break使用方法及示例代码"
 * 功能：用户随机输入数字，总和大于100后终止退出*/

import java.util.Scanner;
public class Program {
	public static void main(String [] args) 
	{
		int sum=0,num=0;
		for(;;)
		{
			System.out.println("请输入一个数字：");
			Scanner sc =new Scanner(System.in);
			num=sc.nextInt();
			sum+=num;
			if(sum>100)
				break;
		}
		System.out.println("sum="+sum);
	}
}


/*
 * "continue语句"使用示例及代码
 * 功能：剔除或禁用数组中的某一个，即在结果中不希望显示它*/

public class Program
{
	public static void main(String [] args) 
	{
		String[] users ={"AAA","BBB","CCC","DDD","EEE"};
		System.out.println("有效输出：");
		for(String user:users)
		{
			if(user=="CCC")
				continue;
			System.out.print(user+"、");
		}
	}
}

 

 
 
5.2、实战——break实现goto功能
 
 

 break语句可以实现goto的功能，并且java定义了break语句的一种扩展形式，来处理退出嵌套很深的循环这个问题。同时这种扩展的break语句带有标签，可以明确指定执行从何处重新开始。标签break语句的通用格式如下：
 
break label；
 

/*
 * "实战"——break实现goto功能*/
public class Program
{
	public static void main(String [] args) 
	{
		int i;		
outer:	for(i=0;i<10;i++)
		{	
			if(i<7)
			{
				System.out.println("外部Goto功能");
				continue outer;
			}
			if(i==5 || i==8)
			{
				System.out.println("x=8");
				break outer;
			}
		}
	}
}

 

 
 

 

欢迎大家来到“Python从零到壹”，在这里我将分享约200篇Python系列文章，带大家一起去学习和玩耍，看看Python这个有趣的世界。所有文章都将结合案例、代码和作者的经验讲解，真心想把自己近十年的编程经验分享给大家，希望对您有所帮助，文章中不足之处也请海涵。
 
Python系列整体框架包括基础语法10篇、网络爬虫30篇、可视化分析10篇、机器学习20篇、大数据分析20篇、图像识别30篇、人工智能40篇、Python安全20篇、其他技巧10篇。您的关注、点赞和转发就是对秀璋最大的支持，知识无价人有情，希望我们都能在人生路上开心快乐、共同成长。
 
本文参考了作者CSDN的文章，链接如下：
 
https://blog.csdn.net/Eastmount
https://github.com/eastmountyxz/Python-zero2one
 
 
 
同时，作者新开的“娜璋AI安全之家”将专注于Python和安全技术，主要分享Web渗透、系统安全、人工智能、大数据分析、图像识别、恶意代码检测、CVE复现、威胁情报分析等文章。虽然作者是一名技术小白，但会保证每一篇文章都会很用心地撰写，希望这些基础性文章对你有所帮助，在Python和安全路上与大家一起进步。
 
 


 
文章目录
 
一.条件语句
1.单分支
2.二分支
3.多分支
  
二.循环语句
1.while循环
2.for循环
3.Break、Continue和Pass语句
4.嵌套循环
  
三.函数
1.自定义函数
2.常见内部库函数
3.第三方库函数
  
四.总结


 


 
 
一.条件语句
 
在讲诉条件语句之前，需要先补充语句块的知识。语句块并非一种语句，它是在条件为真时执行一次或执行多次的一组语句，在代码前放置空格缩进即可创建语句块。它类似于C、C++、Java等语言的大括号（{ }）来表示一个语句块的开始和结束。
 
在Python中使用冒号（:）来标识语句块的开始，块中每一条语句都有缩进并且缩进量相同，当回退到上一层缩进量时，就表示当前语句块已经结束。 下面开始详细讲解条件语句。
 
1.单分支
 
单分支语法如下：
 
if <condition>:
	<statement>
	<statement>
 
< condition > 是条件表达式，基本格式为< expr >< relop >< expr >；< statement >是语句主体。判断条件如果为真（True）就执行语句，如果为假（False）就跳过语句，执行下一条语句。条件判断通常有布尔表达式（True、False）、关系表达式（>、<、>=、<=、= =、!=）和逻辑运算表达式（and、or、not，其优先级从高到低是not、and、or）等。
 
注意：在Python2.x版本中，条件表达式是不强制要求用括号括起来的，但条件表达式后面一定要添加英文冒号字符。
 
a = 10
if a==10:
    print('变量a等于10')
    print(a)
 
输出结果如下：
 
 

 
 
2.二分支
 
二分支语法如下：
 
if <condition>:
	<statement>
	<statement>
else:
	<statement>
	<statement>
 
执行过程如下图所示：
 
 
如果条件语句< condition >为真，if后面的语句就被执行，如果为假，则执行else下面的语句块。条件语句的格式为：< expr >< relop >< expr >，其中< expr >为表达式、为关系操作符。例如：a >= 10、b != 5等。
 
a = 10
if a >= 5:
    print('变量a大于等于5')
    print(a)
else:
    print('变量a小于5')
    print(a)
 
输出结果如下，由于变量a为10，大于5执行if中的语句。
 
 

 
 
3.多分支
 
if多分支由if-elif-else组成，其中elif相当于else if，同时它可以使用多个if的嵌套。具体语法如下所示：
 
if <condition1>:
	<case1 statements>
elif<condition2>:
	<case2 statements>
elif<condition3>:
	<case3 statements>
...
else:
	<default statements>
 
该语句是顺序评估每个条件，如果当前条件分支为True，则执行对应分支下的语句块，如果没有任何条件成立，则执行else中的语句块，其中else是可以省略的。代码如下：
 
num = input("please input:")
num = int(num)
print(num)
if num >= 90:
    print('A Class')
elif num >= 80:
    print('B Class')
elif num >= 70:
    print('C Class')
elif num >=60:
    print('D Class')
else:
    print('No Pass')
 
输出值为76，则在80到70之间，成绩为C等级，输出结果如下图所示。
 
 
注意：由于Python不支持switch语句，所以多个条件判断，只能用elif来实现，如果判断需要多个条件需同时判断时，可以：
 
使用or （或），表示两个条件有一个成立时判断条件成功
使用and （与），表示只有两个条件同时成立的情况下，判断条件才成功
 
# 判断值是否在小于0或大于10
num = 10
if num < 0 or num > 10:    
    print('hello')
else:
    print('undefine')
# 输出结果: undefine


# 判断值是否在0~5或者10~15之间
num = 8
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print('hello')
else:
    print('undefine')
 
输出结果如下图所示：
 
 
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外and和or的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
 
同时，你也可以在同一行的位置上使用if条件判断语句，如下实例。但不见大家使用类似的语法，在我们编写项目或实战中，很可能你的代码会供别人学习，有时你只负责其中一部分，良好的代码格式及注释是非常必要的。
 
var = 520
if (var ==520): print("感谢您关注娜璋AI安全之家")
 

 
 
二.循环语句
 
Python循环语句主要分为while循环和for循环，它允许我们执行一个语句或语句组多次。
 
1.while循环
 
while循环语句的基本格式如下：
 
while <condition>:
	<statement>
else:
	<statement>
 
执行流程如下图所示：
 
 
条件表达式< condition >如果为真时，则循环体重复执行，直到条件判断为假，循环体终止，如果第一次判断条件就为假，则直接跳出循环执行else语句，注意else语句可以省略，同时冒号（:）开始进入循环体，缩进区分语句块。条件语句condition包括布尔表达式（True、False）、关系表达式（>、<、>=、<=、= =、!=）和逻辑运算表达式（and、or、not）等。
 
案例1：1+2+…+100
 
i = 1  
s = 0  
while i <= 100:  
    s = s+i  
    i = i+1  
else:  
    print('over')
print('sum = ', s)
 
这段代码是作者写博客或授课时，讲述循环语句最常用的例子，求1+2+3+…+100的结果，答案是5050。该段代码反复执行“i<=100”判断，当i加到101时，判断i>100为假则结束循环执行else语句。
 
 

 
案例2：循环打开网站
 再举一个实例，通过定义一个while循环，调用webbrowser库的open_new_tab()函数循环打开百度首页网址，下面代码反复打开了百度首页5次。完整代码如下：
 
import webbrowser as web  
import time  
import os

i=0  
while i<5:  
    web.open_new_tab('http://www.baidu.com')  
    i=i+1  
    time.sleep(0.8)  
else:  
    os.system('taskkill /F /IM iexplore.exe')  
print('close IE')
 
代码是调用webbrowser库中open_new_tab()函数打开窗口（百度链接）5次。
 
 
最后循环结束执行os.system()操作系统函数，调用taskkill命令结束IE浏览器进程（Iexplore.exe），其他浏览器程序修改为chrome.exe、qq.exe或firefox.exe即可。其中参数“/F”表示强行终止程序，“/IM”表示图像，如下图所示。
 
 
注意：上述代码实现了循环打开某个网站，可以应用于刷取网页浏览量或Web开发测试等功能。比如新浪博客等部分网页打开一次浏览器会计算一次浏览次数，通过上面这段代码可以循环增加阅读量，部分网站又是通过浏览量进行排序的，不妨试试看。作者引入该代码仅为读者了解循环，也为后面的爬虫知识埋下伏笔。
 

 
案例3：奇数和偶数计算
 最后补充一个奇数和偶数计算的案例，其基本流程如下图所示：
 
 
代码如下：
 
numbers = [12, 37, 5, 42, 8, 3]
even = []
odd = []
while len(numbers) > 0:
    number = numbers.pop()
    if(number % 2 == 0):      #偶数判断
        even.append(number)
    else:
        odd.append(number)
#输出结果
print(even)
print(odd)
 
输出结果如下：
 
[8, 42, 12]
[3, 5, 37]
 

 
 
2.for循环
 
for循环语句的基本格式如下：
 
for <var> in <sequence>:
	<statement>
	<statement>
 
流程图如下：
 
 
自定义循环变量var遍历sequence序列中的每一个值，每个值执行一次循环的语句块。sequences表示序列，常见类型有list(列表)、tuple(元组)、strings(字符串)和files(文件)。下面的代码是计算1到100的求和，输出三角形星号的示例。
 
#元组循环
tup = (1,2,3,4,5)  
for n in tup:  
    print(n)  
else:  
    print('End for\n')
    
#计算1+2+...+100
s = 0
for i in range(101):
    s = s + i
print('sum =', s)

#输出三角形星号
for i in range(10):
    print("*"*i)
 
输出结果如下图所示，循环遍历元组tup变量中的值，依次获取并输出；然后计算1累加到100，range(101)表示依次获取101范围内的100个数字，其累加结果为5050；最后输出星号三角形，print “ * ” * i 代码中，第一个星号表示输出星号字符串，第二个星号是乘法，表示输出5个星号，终输出三角形。打印图形是编程基础，使用Python实现要比C语言容易很多，但原理逻辑是一样的。
 
 

 
 
3.Break、Continue和Pass语句
 
Break和Continue是两个常用的跳出循环语句。
 
Break语句
 跳出最内层while、for循环，在语句块执行过程中终止循环，并且跳出整个循环。
 
s = 0
num = 0
while num<20:
    num += 1
    s += num
    if s > 100:
        break
print("The sum is", s)
# The sum is 105
 
当求和变量s大于100的时候，进入if判断，执行break跳出循环，最后输出105。
 

 
Continue语句
 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
 
for num in range(10):
    if num % 2 == 0:
        print("even number:", num)
        continue
    print("number:",num)
 
输出结果如下，当为偶数的时候continue跳出当前循环，for循环中只输出偶数。
 
>>> 
even number: 0
number: 1
even number: 2
number: 3
even number: 4
number: 5
even number: 6
number: 7
even number: 8
number: 9
>>> 
 

 
pass语句
 pass语句是空语句，为了保持程序结构的完整性所使用的。
 
# 输出 Python 的每个字母
for letter in 'Python':
   if letter == 'h':
      pass
      print('这是 pass 块')
   print('当前字母 :', letter)
print("Good bye!")
 
输出结果如下图所示：
 
 

 
 
4.嵌套循环
 
while基本语法如下：
 
while expression:
   while expression:
      statement(s)
   statement(s)
 
for基本语法如下：
 
for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)
 
下面以最简单的冒泡排序算法来补充循环嵌套知识。冒泡排序是最常见到的排序算法，也是很基础的一种排序算法。它的实现思想是：
 
相邻的两个元素进行比较，然后把较大的元素放到后面（正向排序），在一轮比较完后最大的元素就放在了最后一个位置，像鱼儿在水中吐的气泡在上升的过程中不断变大。
 
def bubble_sort(list):
    count = len(list)
    for i in range(count):
        for j in range(i + 1, count):
            if list[i] > list[j]:
                list[i], list[j] = list[j], list[i]
    return list

#排序算法
list = [3, 91, 23, 14, 56, 9]
print("排序前:", list)
res = bubble_sort(list)
print("排序后:", res)
 
输出结果如下：
 
 
你可能会疑惑bubble_sort()是什么？其实它是一个自定义函数，下面我们马上讲解。
 

 
 
三.函数
 
当读者需要完成特定功能的语句块时，需要通过调用函数来完成对应的功能。函数分为无参数函数和有参数函数，当函数提供不同的参数时，可以实现对不同数据的处理。下面从自定义函数、系统自带函数、第三方库函数三个方面进行讲解。
 
1.自定义函数
 
(1) 定义方法
 为了简化编程，提高代码的复用性，可以自定义函数，函数定义如下：
 
def funtion_name([para1,para2...paraN]):
	statement1
    statement2
      ....
    [return value1,value2...valueN]
 
其中：
 
定义函数需要使用def关键词
function_name表示函数名，后面的冒号（:）不要忘记，并且缩进
[para1,para2…paraN]表示参数，可以省略，也可以多个参数
[return value1,value2…valueN]表示返回值，可以无返回值，也可以多个返回值
需要注意的是自定义函数有返回值，主调函数就需要接受返回的结果
 
函数调用时，形参被赋予真实的参数，然后执行函数体，并在函数结束调用时返回结果。Return语句表示退出函数并返回到函数被调用的地方，返回值传递给调用程序。
 
首先来看一个无返回值的求和函数fun1()，代码如下：
 
#函数定义
def fun1(a,b):
    print(a,b)
    c = a + b
    print('sum =',c)

#函数调用
fun1(3,4)
# 3 4
# sum = 7
 
再来看一个包含多个参数返回的计算器函数fun2()，代码如下，return返回五个结果。
 
#函数定义
def fun2(a,b):  
    print(a,b)
    X = a + b  
    Y = a - b  
    Z = a * b  
    M = a / b  
    N = a ** b  
    return X,Y,Z,M,N

#函数调用
a,b,c,d,e = fun2(4,3)  
print('the result are ',a,b,c,d,e)
re = fun2(2,10)  
print(re)
 
输出结果如下，依次返回加法、减法、乘法、除法、幂运算结果。
 
>>> 
4 3
the result are  7 1 12 1.3333333333333333 64
2 10
(12, -8, 20, 0.2, 1024)
>>> 
 

 
(2) 自定义函数参数含预定义
 预设值是在自定义函数基础上，对某些参数赋予预定义值。例如：
 
def fun3(a,b,c=10):
    print(a,b,c)
    n = a + b + c
    return n
  
print('result1 =',fun3(2,3))
print('result2 =',fun3(2,3,5))
 
第一次调用a为2，b为3，c为预定义值10，求和输出15；第二次调用修改了预定义值c，赋值为5，求和即为2+3+5=10。
 
 
注意：预定义值得参数不能先于无预定义值参数；同时，函数调用时，建议采用一对一赋值，也可以在函数调用中给出具体形参进行赋值，但需要注意的是在函数调用过程中（使用函数时），有预定义值的参数不能先于无预定义值参数被赋值。
 
 
2.常见内部库函数
 
Python系统内部提供了一些库函数供大家使用，这里主要介绍最常见的四个库函数，即str字符串库函数、math数据库函数、os操作系统库函数、socket网络套接字库函数。Python常见内部库函数如下：
 
 
下面代码是这四个常见内部库函数的具体用法，代码如下：
 
# -*- coding:utf-8 -*-
#字符串库函数
str1 = "hello world"
print('计算字符串长度:', len(str1))
str2 = str1.title()
print('首字母大写标题转换:', str2)
str3 = '12ab34ab56ab78ab'
print('字符串替换:', str3.replace('ab',' '))

#数学库函数
import math
print(math.pi)
num1 = math.cos(math.pi/3)
print('余弦定律:', num1)
num2 = pow(2,10)
print('幂次运算:', num2)
num3 = math.log10(1000)
print('求以10为底的对数:', num3)

#操作系统库函数
import os
print('输出当前使用平台:', os.name)
path = os.getcwd()
print('获取当前工作目录', path)
os.system('taskkill /F /IM iexplore.exe') #关闭浏览器进程

#网络套接字库函数
import socket
ip = socket.gethostbyname('www.baidu.com')
print('获取百度ip地址', ip)
 
输出结果如下图所示。
 
 

 
 
3.第三方库函数
 
Python作为一门开源语言，它支持各种第三方提供的开源库供我们使用。其使用第三方函数库时的具体格式为：
 
module_name.method(parametes)
 
表示“第三方函数名.方法(参数)”。例如httplib\httplib2库是针对HTTP和HTTPS的客户端协议，使用httplib2库函数之前，如果没有安装httplib2库会报错“ImportError: No module named httplib2”，如图2.18所示。
 
 
在Linux环境中，输入命令“easy_install httplib2”可以实现自动安装扩展包，Windows环境下需要安装pip或easy_install工具，再调用命令执行安装。在后续文章会讲解pip安装工具及用法，后面章节也会介绍各种第三方库函数实现数据爬取和分析操作。
 

 
 
四.总结
 
无论如何，作者都希望这篇文章能给您普及一些Python知识，更希望您能跟着我一起写代码，一起进步。如果文章能给您的研究或项目提供一些微不足道的思路和帮助，就更欣慰了。作者最大的期望就是文章中的一些故事、话语、代码或案例对您有所帮助，致那些努力奋斗的人。
 
最后，真诚地感谢您关注“娜璋之家”公众号，感谢CSDN这么多年的陪伴，会一直坚持分享，希望我的文章能陪伴你成长，也希望在技术路上不断前行。文章如果对你有帮助、有感悟，就是对我最好的回报，且看且珍惜！2020年8月18日建立的公众号，再次感谢您的关注，也请帮忙宣传下“娜璋之家”，哈哈~初来乍到，还请多多指教。
 
 
遗憾，让我们懂得完美。
 逝去，让我们不断前行。
 她夜色中的身姿是那么的美。
 
(By:娜璋之家 Eastmount 2020-09-09 夜于武汉 https://blog.csdn.net/Eastmount )
 
参考文献如下：
 [1] 作者书籍《Python网络数据爬取及分析从入门到精通》
 [2] 作者博客：https://blog.csdn.net/Eastmount
 [3] https://www.runoob.com/python/python-if-statement.html