2160人阅读
java笔记（12）
一，打印三角形（for循环嵌套）
1.用*打印直角三角形
需求：打印如下直角三角形
采用for嵌套循环
外层控制行数
内层控制列数（列数为变量,每次均减1）
class ForForDemo {
public static void main(String[] args) {
System.out.println("--------------------------");
System.out.println("第一种方法，定义列数变量z1");
int z1 =5;
for (int x=0;x&5;x++ ){
for (int y=0;y&z1 ;y++ ){
System.out.print("*");
System.out.println("");
System.out.println("--------------------------");
System.out.println("第二种方法，定义列数变量z2");
int z2 =0;
for (int x=0;x&5 ;x++ ){
for (int y=z2;y&5 ;y++ ){
System.out.print("*");
System.out.println("");
System.out.println("----------------------------------");
System.out.println("第三种方法，列变量用行的变量来代替");
for (int x =0;x&5 ;x++ ){
for (int y=x;y&5 ;y++ )
System.out.print("*");
System.out.println("");
System.out.println("------------------------");
System.out.println("打印与之相反的直角三角形");
for (int x=0;x&5 ;x++ ){
for (int y=0;y&=y++ ){
System.out.print("*");
System.out.println("");
运行结果：
2.正三角形
需求：打印如下正三角形(倒三角形和正三角形)
外循环控制行数
内循环首位每一层比上层多一空格,列数减1
class TriangleDemo {
public static void main(String[] args) {
for (int x=0;x&5 ;x++ ){
for (int n=0;n&x;n++){
System.out.print(" ");
for (int y=0;y&5-y++ ){
System.out.print("* ");
System.out.println("");
System.out.println("---------");
for (int x=0;x&5 ;x++ ){
for (int n=x;n&4 ;n++ ){
System.out.print(" ");
for (int y=0;y&=y++ ){
System.out.print("* ");
System.out.println("");
二，排序（for循环嵌套if语句）和二分法查找（while循环嵌套if语句）
1，选择排序
1、首先：将数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。
2、然后：再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数第二小的元素。
3、最后：依次类推，直到最后一个元素。
代码示例：
class SelectDemo {
public static void printArray(int []arr){
System.out.print("[");
for (int x=0;x&arr.x++ ){
if (x!=arr.length-1)
System.out.print(arr[x]+",");
System.out.println(arr[x]+"]");
public static void swap(int[]arr,int a,int b) {
temp = arr[a];
arr[a] = arr[b];
public static void selectSort(int []arr){
for (int x=0;x&arr.length-1 ;x++ ){
for (int y=x+1;y&arr.y++ )
if (arr[x]&arr[y])
swap(arr,x);
public static void main(String[] args) {
int []arr =new int []{2,6,4,1,8,9};
System.out.println("排序前：");
printArray(arr);
selectSort(arr);
System.out.println("排序后：");
printArray(arr);
2，冒泡排序
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
2、然后第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
3、最后依照此方式，一直到只有第一和第二个元素互相比较而结束。
代码示例：
public static void bubbleSort(int[]arr) {
for (int x=0;x&arr.length-1;x++){
for(int y=0;y&arr.length-1-x;y++){
/内循环将相邻的两个数进行比较，每次从第一个数开始并依次减少一次
if(arr[y]& arr[y+1])
swap(arr,y,y+1);
注：实际开发中直接调用Arrays类中的sort()方法（导入util下的Arrays包）即可！
3，二分法查找（while循环嵌套if语句）
前提：数组有序。
1、定义三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为
（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max=mid-1，mid=(max+min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min=mid+1，mid=(max+min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值（此处为while循环的结束条件），此时返回-1。
代码实现：
public static int binarySearch(int[]arr,int key){
int min=0;
int max =arr.length-1;
int mid =(min+max)/2;
while(min&=max){
if (arr[mid]&key){
min = mid+1;
mid = (min+max)/2;
else if(arr[mid]&key){
max = mid -1;
mid = (min+max)/2;
return -1;
需求：向数组{13,15,19,28,33,45,78,106}中插入值为44的元素，求出插入的角标和插入后的新数组
思路：采用二分法查找，若数组中有该数，直接返回mid,没有该数返回min。
代码示例：
class SearchDemo {
public static int searchDemo(int []arr,int key){
int min=0,max=arr.length-1,
while (min&=max) {
mid=(min+max)/2;
if (arr[mid]&key)
min=mid+1;
else if (arr[mid]&key)
max=mid-1;
else return
public static void main(String[] args) {
int []arr=new int[]{13,15,19,28,33,45,78,106};
int []arr_2=new int[9];
System.out.println("原数组：");
printArray(arr);
int index =searchDemo(arr,44);
System.out.println("插入的数为44；index="+index);
for (int x=0;x&x++ )
arr_2[x]=arr[x];
arr_2[index]=44;
for (int x=index+1;x&9 ;x++ )
arr_2[x]=arr[x-1];
System.out.println("新数组：");
printArray(arr_2);
public static void printArray(int []arr){
System.out.print("[");
for (int x=0;x&arr.x++ ) {
if (x!=arr.length-1)
System.out.print(arr[x]+",");
System.out.println(arr[x]+"]");
运行结果：
注：实际开发中直接调用Arrays类中的binarySearch()方法（导入util下的Arrays包）即可！
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：3764次
排名：千里之外
原创：14篇
(10)(1)(3)关于java基本数据类型数组的疑问 - ITeye问答
以前一直没注意，现在才突然发现了， 也许是自己基础不够扎实。
我在声明int数组的时候
int[]
int[] num = {};
都是对的，对于第二种方式中,可以得到num.
现在就有个问题了，就是如何动态确定num数组的维数
例如
int[10] num= {};这种写法在编译过程中就通不过，于是我就用了 int[] num = new int[10];这在编译和执行中都没问题.
但是我个人觉得基本数据类型，跟他们的封装类不同，例如 int--&Integer
new Integer[10],我没意见
但
new int[10]
总觉得不妥，于是上网查了一下，很多人都在用 new int[length];
但也有人说这中写法是不对的
想问问大家，这种动态声名基本类型数组，正确的做法呢？
用list vector集合来装啊，长度不用理会它啊
java没有提供你可以自己写个
int [] a,b;
&&&&&& a=new int[3];
if a.leng&3;
&&&&&& b=new int[a.leng*2]
&&&&&& b.add(each a)
数组和其它语言差别很大。
java 中数组一旦分配，不无法像php语言那样对数组大小任意修改的。
上面有点笔误，纠正一下：
int[] numbers = new int[3];// == int[] numbers = new int[]{0,0,0};
有什么不对的？都对～
int[]//null
int[] numbers = {};//length == 0 or == ini[] numbers = new int[0];
ini[] numbers = new int[3];// == ini[] numbers = new int[]{0,0,0};
让我引用JVM Spec 2nd的一段：
Java Virtual Machine Specification, 2nd Edition 写道2.4.6 Reference Types, Objects, and Reference Values
There are three kinds of reference types: the class types (§2.8), the interface types (§2.13), and the array types (§2.15). An object is a dynamically created class instance or an array. The reference values (often just references) are pointers to these objects and a special null reference, which refers to no object.
于是Java中的“对象”就是“一个动态分配空间的类实例或者数组”。
所有对象都是在堆上分配空间的，数组也不例外，无论数组里装的是原始类型还是引用类型的数据。
我还是觉得区分清楚“对象”与“引用”很重要。楼主或许有兴趣看看。
然后之前的另一篇笔记或许也可以读读，
java不比c++，php，动态生成很困难吧~
为什么一定要用数组呢，可变长度的如vector，list都可以用啊~足够用的
int[] num = new int[10]; 是正确的,我也是这么写的.在java中万事万物都是对象.基本数据类型也是对象,一样也可以用new关键字
已解决问题
未解决问题Java for循环的几种用法分析
字体：[ ] 类型：转载 时间：
本篇文章小编为大家介绍，Java for循环的几种用法分析。需要的朋友参考下
J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。
在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现（当然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其它循环常用得多）。
对于遍历数组，这个循环一般是采取这样的写法：
清单1：遍历数组的传统方式 代码如下:&/* 建立一个数组 */&int[] integers = {1， 2， 3， 4};&/* 开始遍历 */&for (int j = 0; j & integers. j++) {&&&& int i = integers[j];&&&& System.out.println(i);&}&而对于遍历Collection对象，这个循环则通常是采用这样的形式：
清单2：遍历Collection对象的传统方式 代码如下:/* 建立一个Collection */&String[] strings = {"A"， "B"， "C"， "D"};&Collection stringList = java.util.Arrays.asList(strings);&/* 开始遍历 */&for (Iterator itr = stringList.iterator(); itr.hasNext();) {&&&& Object str = itr.next();&&&& System.out.println(str);&}而在Java语言的最新版本――J2SE 1.5中，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。
&1、 第二种for循环
不严格的说，Java的第二种for循环基本是这样的格式：
&for (循环变量类型 循环变量名称 : 要被遍历的对象) &循环体
借助这种语法，遍历一个数组的操作就可以采取这样的写法：
清单3：遍历数组的简单方式 代码如下:&/* 建立一个数组 */&int[] integers = {1， 2， 3， 4};&/* 开始遍历 */&for (int i : integers) {&&&& System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */&}这里所用的for循环，会在编译期间被看成是这样的形式：
清单4：遍历数组的简单方式的等价代码 代码如下:&/* 建立一个数组 */&int[] integers = {1， 2， 3， 4};&/* 开始遍历 */&for (int 变量名甲 = 0; 变量名甲 & integers. 变量名甲++) {&&&& System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */&}这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。
而遍历一个Collection的操作也就可以采用这样的写法：
清单5：遍历Collection的简单方式 代码如下:&/* 建立一个Collection */&String[] strings = {"A"， "B"， "C"， "D"};&Collection list = java.util.Arrays.asList(strings);&/* 开始遍历 */&for (Object str : list) {&&&& System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */&}这里所用的for循环，则会在编译期间被看成是这样的形式：
清单6：遍历Collection的简单方式的等价代码 代码如下:&/* 建立一个Collection */&String[] strings = {"A"， "B"， "C"， "D"};&Collection stringList = java.util.Arrays.asList(strings);&/* 开始遍历 */&for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {&&&& Object str = 变量名乙.next();&&&& System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */&}
这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。
因为在编译期间，J2SE 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。
不用“foreach”和“in”的原因
Java采用“for”（而不是意义更明确的“foreach”）来引导这种一般被叫做“for-each循环”的循环，并使用“:”（而不是意义更明确的“in”）来分割循环变量名称和要被遍历的对象。这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题――在Java语言中，不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字（例如java.lang.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”）。
的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。不过这种会使语法变复杂的策略，并没有得到广泛的采用。
&“for-each循环”的悠久历史
“for-each循环”并不是一个最近才出现的控制结构。在1979正式发布的Bourne shell（第一个成熟的UNIX命令解释器）里就已经包含了这种控制结构（循环用“for”和“in”来引导，循环体则用“do”和“done”来标识）。
2、防止在循环体里修改循环变量
在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。
Java提供了一种机制，可以在编译期间就把这样的操作封杀。具体的方法，是在循环变量类型前面加上一个“final”修饰符。这样一来，在循环体里对循环变量进行赋值，就会导致一个编译错误。借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。
清单7：禁止重新赋值 代码如下:&int[] integers = {1， 2， 3， 4};&for (final int i : integers) {&&&& i = i / 2; /* 编译时出错 */&}注意，这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。
清单8：允许修改状态 代码如下:&Random[] randoms = new Random[]{new Random(1)， new Random(2)， new Random(3)};&for (final Random r : randoms) {&&&& r.setSeed(4); /* 将所有Random对象设成使用相同的种子 */&&&& System.out.println(r.nextLong()); /* 种子相同，第一个结果也相同 */&}3. 类型相容问题
为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。这些限制之下，循环变量的类型可以有这样一些选择：
循环变量的类型可以和要被遍历的对象中的元素的类型相同。例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。
清单9：使用和要被遍历的数组中的元素相同类型的循环变量 代码如下:&int[] integers = {1， 2， 3， 4};&for (int i : integers) {&&&& System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */&}清单10：使用和要被遍历的Collection中的元素相同类型的循环变量&Collection& String& strings = new ArrayList& String&();&strings.add("A");&strings.add("B");&strings.add("C");&strings.add("D");&for (String str : integers) {&&&& System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */&}
循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection& String&（全部元素都是String的Collection）等。
清单11：使用要被遍历的对象中的元素的上级类型的循环变量&String[] strings = {"A"， "B"， "C"， "D"};&Collection& String& list = java.util.Arrays.asList(strings);&for (Object str : list) {&&&& System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */&}
循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类（Wrapper Classes）之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个Collection& Byte&，也是可行的。
清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量&int[] integers = {1， 2， 3， 4};&for (Integer i : integers) {&&&& System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */&}
注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。
可以限定元素类型的Collection
截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型――它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型（Generics）”机制之后，这个问题才得到了解决。现在可以用Collection& T&来表示全部元素类型都是T的Collection。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具java里for循环与它的前后变量关系 -
- ITeye技术网站
今天在偶然阅读一份某企业的笔试题的时候看到这样一道java选择题：
下述程序代码中有语法错误的行是（& ）。
int&& i, la[10]& ,& lb[10];/*a*/
for(int i=0;i&=9;i++)/*b*/
la[i]=0;/*c*/
A.a B.b& C.c& D.d
题目本身很简单，相信大家已经有自己的选择了。
这里我要说的是，我的选择是AB。
首先数组在初始化的时候才能给定长度，无可置疑。
可能有人要问了变量i是否重复定义了？
for(int i=0;i&=9;i++)
以上语句是否有问题呢？
可能会有人说一样的。但是问题就是，不一样！
你也可以试验一下，以上语句没有问题。因为for循环相当于代码段，是独立的一个块。但是它比较特殊，不同于函数的是，对于函数中定义的变量，有他的作用范围；而位于for语句之前定义的变量或属性将会被for语句识别，并可以直接使用；而位于for语句之后的定义则会被for代码块遗忘，相当于for循环运行完成后，会将for循环以及其之前的所有变量和属性释放，程序告一段落。for循环之后的程序块将另起炉灶。这就是为什么位于for之前的重复命名不被允许的原因。
原谅我如此愚钝，才知道这么回事....
浏览: 16159 次
来自: 北京
可以使用在线按钮样式生成器:http://buttoncssg ...java中for循环的三种写法
int[] integers = {1, 2, 3, 4};&
for (int j = 0; j & integers. j++)
integers[j];&&
System.out.println(i);&&
String[] strings = {"A", "B", "C",
Collection stringList =
java.util.Arrays.asList(strings);&&
for (Iterator itr = stringList.iterator(); itr.hasNext();)
& Object str =
itr.next();&&
System.out.println(str);&&
int[] integers = {1, 2, 3,
for (int i : integers) {&&
& System.out.println(i);
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。