For循环、增强for循环

For循环

虽然所有循环结构都可以用 while或者do...while表示,但是Java提供了另一种语句——for循环,使一些循环结构变得更加简单。

for循环语句是支持迭代的一种通用结构,是最有效的、最灵活的循环结构。

public static void main(String[] args) {
       int a = 1;//初始化条件

       while (a <= 100) {
           System.out.println(a);//循环体
           a+=2; //迭代
      }

       System.out.println("while循环结束!");

       //初始化//判断条件 //迭代
       for (int i = 0; i < 100; i++) {
           System.out.println(i);
      }
       System.out.println("for循环结束!");
   /*
   关于for循环有以下几点说明:
   最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
   然后,检测布尔表达式的值,如果为true,循环体被执行。如果为false,循环终止,可以执行循环体后面的语句。
   执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)。
   再次检测布尔表达式,循环执行上面的过程。
   */
   //死循环
   for(; ; ){
       
  }
  }

 

for循环执行的次数是在执行前就确定的。语法格式如下:

for(初始化; 布尔表达式; 更新){
   //代码语句
}

练习1:计算0到100之间的奇数和偶数的和

public static void main(String[] args) {
       //练习1:计算0到100之间的奇数和偶数的和

       int oddSum = 0;
       int evenSum = 0;

       for (int i = 0; i < 100; i++) {
           if (i%2 != 0) {//奇数
               oddSum+=i; //oddSum = oddSum + i;
          }else {  //偶数
               evenSum+=i;
          }
      }

       System.out.println("奇数的和:" + oddSum);
       System.out.println("偶数的和:" + evenSum);
  }

//输出结果
奇数的和:2500
偶数的和:2450

Process finished with exit code 0

 

练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

public static void main(String[] args) {
       //练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

       for (int i = 0; i < 1000; i++) {
           if (i%5==0){
               System.out.print(i+"\t");
          }
           if (i%(5*3)==0){//每行
               System.out.println();
               //System.out.print("\n");
          }
      }

       //println 输出完会换行
       //print 输出完不会换行
  }

//输出结果
0
5 10 15
20 25 30
35 40 45
50 55 60
65 70 75
80 85 90
95 100 105
110 115 120
125 130 135
140 145 150
155 160 165
170 175 180
185 190 195
200 205 210
215 220 225
230 235 240
245 250 255
260 265 270
275 280 285
290 295 300
305 310 315
320 325 330
335 340 345
350 355 360
365 370 375
380 385 390
395 400 405
410 415 420
425 430 435
440 445 450
455 460 465
470 475 480
485 490 495
500 505 510
515 520 525
530 535 540
545 550 555
560 565 570
575 580 585
590 595 600
605 610 615
620 625 630
635 640 645
650 655 660
665 670 675
680 685 690
695 700 705
710 715 720
725 730 735
740 745 750
755 760 765
770 775 780
785 790 795
800 805 810
815 820 825
830 835 840
845 850 855
860 865 870
875 880 885
890 895 900
905 910 915
920 925 930
935 940 945
950955960
965970975
980985990
995
Process finished with exit code 0

练习3:打印九九乘法表

public static void main(String[] args) {
       //练习3:九九乘法表
       for (int i = 1; i <= 9; i++) {
           for (int j = 1; j <= i; j++) {
               System.out.print(i+"*"+j+"="+(i*j) + "\t");
          }
           System.out.println();
      }
  }

1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

Process finished with exit code 0

增强for循环

这里简单了解一下,之后数组我们重点使用

Java5引入了一种主要用于数组或集合的增强型for循环。

Java增强for循环语法格式如下:

for(声明语句 : 表达式) {
   //代码句子
}

声明语句:声明信贷局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。

表达式:表达式是要访问的数组名,或者是返回为数组的方法。

public static void main(String[] args) {
       int[] numbers = {10,20,30,40,50};//定义了一个数组

       for (int i = 0; i < 5; i++) {
           System.out.println(numbers[i]);
      }
       System.out.println("=====================");
       //遍历数组的元素
       for (int x : numbers) {
           System.out.println(x);
      }
  }

//输出结果
10
20
30
40
50
=====================
10
20
30
40
50

Process finished with exit code 0

 

每日Java面试题

一.hashCode()和equals()的区别?

下边从两个角度介绍了他们的区别:一个性能,一个是可靠性。他们之间的主要区别也基本体现在这里。

  1. equals()既然已经能实现对比的功能了,为什么还要hashCode()呢?

因为重写的equals()里一般比较的比较全面比较复杂,这样效率比较低,而利用hashCode()进行对比,则只要生成一个hash值进行比较就可以了,效率很高。

  1. hashCode()既然效率这么高为什么还要equals()呢?

因为hashCode()并不是完全可靠,有时候不同的对象他们生成的hashCode也会一样(生成hash值得公式可能存在的问题),所以hashCode()只能说是大部分时候可靠,并不是绝对可靠,所以我们可以得出(PS:一下两条结论是重点,很多人面试的时候说不出来):

equals()相等的两个对象他们的hashCode()肯定相等,也就是用equals()对比是绝对可靠的。

hashCode()相等的两个对象他们的equals()不一定相等,也就是hashCode()不是绝对可靠的。

扩展:

  1. 阿里巴巴开发规范明确规定:

只要重写equals,就必须重写hashCode;

因为Set存储的是不重复的对象,依据hashCode和equals进行判断,所以Set存储的对象必须重写这两个方法:

如果自定义对象作为Map的健,那么必须重写hashCode和equals;

String重写了hashCode和equals方法,所以我们可以非常愉快地使用String对象作为key来使用;

  1. 什么时候需要重写?

一般的地方不需要重载hashCode,只有当类需要放在HashTable、HashMap、HashSet等等hash结构的集合时才会重载hashCode。

  1. 那么为什么要重载hashCode呢?

如果你重写了equals,比如说是基于对象的内容实现的,而保留hashCode的实现不变,那么很可能某两个对象明明是"相等",而hashCode却不一样。

这样,当你用其中的一个作为健保存到hashMap、hashTable或hasSet中,再以"相等的"找另一个作为键值去查找他们的时候,则根本找不到。

  1. 为什么equals()相等,hashCode就一定要相等,而hashCode相等,却不要求equals相等?

    因为是按照hashCode来访问小内存块,所以hashCode必须相等。

    HashMap获取一个对象是比较key的hashCode相等和equals为true。

    之所以hashCode相等,却可以equals不等,就比如ObjectA和ObjectB他们都有属性name,那么hashCode都以name计算,所以hashCode一样,但是两个对象属于不同类型,所以equals为false。

  2. 为什么需要hashCode?

通过hashCode可以很快的查到小内存块。

通过hashCode比较比equals方法块,当get时先比较hashCode,如果hashCode不同,直接返回false。

二、Java中操作字符串都有那些类?它们之间有什么区别?

String、StringBuffer、StringBuilder。

String和StringBuffer、StringBuilder的区别在于String声明的是不可变的对象,每次操作都会生成新的String对象,然后将指针指向新的String对象,而StringBuffer、StringBuilder可以在原有对象的基础上进行操作,所以在经常改变字符串内容的情况下最好不要使用String。

StringBuffer和StringBuilder最大的区别在于,StringBuffer是线程安全的,而StringBuilder是非线程安全的,但StringBuilder的性能却高于StringBuffer,所以在单线程推荐使用StringBuilder,多线程环境下推荐使用StringBuffer。

三、String str = "a"与 String str = new String("a")一样吗?

不一样,因为内存的分配方式不一样。

String str = "a";->常量池 String str = new String("a");->堆内存

posted @   崔九八  阅读(148)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 10年+ .NET Coder 心语 ── 封装的思维:从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 周边上新:园子的第一款马克杯温暖上架
· 提示词工程——AI应用必不可少的技术
· Open-Sora 2.0 重磅开源!
点击右上角即可分享
微信分享提示