class shuzup
{
public static void paixu(int[] dx)
  {
  for(int x = 0;x<dx.length-1;x++)
   {
   for(int y=x+1;y<dx.length;y++)
    {
    if(dx[x]>dx[y]);
     {
      int temp = dx[x];
      dx[x] = dx[y];
      dx[y] = temp;
     }
    }
   }
  }
public static void shuzu(int[] arr)
{
  {System.out.print("[");
  for(int x=0;x<arr.length;x++)
   {
   if(x!=arr.length-1)
    {System.out.print(arr[x]+", ");}
   else
    {System.out.println(arr[x]+"]");}
   }
  }
}
  public static void main(String[] args)
{
  int[] dx = {5,1,6,4,2,8,9};
  shuzu(dx);
  paixu(dx);
  shuzu(dx);
}
}


在函数paixu里面的for(int y=x+1;y<dx.length;y++)跟了分号之后为什么输出是把整个数组调转了。
不是应该只有比较没有执行if的语句吗？就是没有执行if后面跟的大括号？

刚去吃饭了……等的时间真长啊
if (dx[x] > dx[y])；//这是一条语句,用“;”结尾的表达式就是一条语句，只不过条件判断语句没有执行体罢了
//用花括号括起来的又是另外一部分，是一个块。它和if语句没有任何关系；     

{
      int temp = dx[x];
      dx[x] = dx[y];
      dx[y] = temp;
     }

额，感谢LS各位的帮助~总算理清了。
在代码中：if(dx[x]>dx[y])；加了后就完全没有作用，变成了废话。

不会是加了；后这段   
  {
      int temp = dx[x];
      dx[x] = dx[y];
      dx[y] = temp;
     }
不在算是if语句，变成内循环for的语句？

感谢LS，但是还是不明，尤其含义是：永远拿角标为x的元素与角标为y的元素交换
if (dx[x] > dx[y])；加了后
     {
      int temp = dx[x];
      dx[x] = dx[y];
      dx[y] = temp;
     }
不是跳过吗？怎么形成交换了？如果没大括号还可以判定为  int temp = dx[x];离if最近为if语句不执行， dx[x] = dx[y];和dx[y] = temp;执行。
但是我有大括号把3段都归为if执行语句了啊

package exception;

class shuzup {
        public static void paixu(int[] dx) {
                for (int x = 0; x < dx.length - 1; x++) {
                        for (int y = x + 1; y < dx.length; y++) {
                                if (dx[x] > dx[y])
                                        ;//这里面可以正常运行，是没有错的
                                //下面的是代码块，也没有错的，而且y的作用范围依然在，重点在一下三句
                                //含义是：永远拿角标为x的元素与角标为y的元素交换，
//                                这是数组值5, 1, 6, 4, 2, 8, 9
//                                当x=0的时候
//                                当y==1的时候变成1, 5, 6, 4, 2, 8, 9
//                                当y==2的时候变成6, 5, 1, 4, 2, 8, 9
//                                当y==3的时候变成4, 5, 1, 6, 2, 8, 9
//                                当y==4的时候变成2, 5, 1, 6, 4, 8, 9
//                                当y==5的时候变成8, 5, 1, 6, 4, 2, 9
//                                当y==5的时候变成9, 5, 1, 6, 4, 2, 8   这个时候确定了x=0的位置为9
//                                当x=1的时候
//                                当y==2的时候变成9, 1, 5, 6, 4, 2, 8
//                                当y==3的时候变成9, 6, 5, 1, 4, 2, 8
//                                当y==4的时候变成9, 4, 5, 1, 6, 2, 8
//                                当y==5的时候变成9, 2, 5, 1, 6, 4, 8
//                                当y==5的时候变成9, 8, 5, 1, 6, 4, 2  这个时候确定了x=1的位置为8
//                                后面的以此类推
                                {       
                                        int temp = dx[x];
                                        dx[x] = dx[y];
                                        dx[y] = temp;
                                        // 利用该输出语句来检查每次产生的结果是否正确
                                        System.out.print(dx[y]+" ");
                                }
                        }
                        System.out.println();
                }
        }

        public static void shuzu(int[] arr) {
                {
                        System.out.print("[");
                        for (int x = 0; x < arr.length; x++) {
                                if (x != arr.length - 1) {
                                        System.out.print(arr[x] + ", ");
                                } else {
                                        System.out.println(arr[x] + "]");
                                }
                        }
                }
        }

        public static void main(String[] args) {
                int[] dx = { 5, 1, 6, 4, 2, 8, 9 };
                shuzu(dx);
                paixu(dx);
                shuzu(dx);
        }
}

public static void selectSort(int[] arr) {
                for (int x = 0; x < arr.length - 1; x++) {
                        for (int y = x + 1; y < arr.length; y++) {
                                if (arr[y] < arr[x]) {
                                        swap(arr, x, y);
                                }
                        }
                }
        }
private static void swap(int[] arr, int a, int b) {
                int temp = arr[a];
                arr[a] = arr;
                arr = temp;
这样就可以排序了   你的if语句后边不能有分号  如果有分号表示是一行空语句 没有按照理想中的交换两个值  交换值的过程是通过代码块来执行的

额~我重新编辑了一下，现在的代码就是打印倒叙的代码，编译肯定能通过。结果是完全数组调转了

1. package com.heima.test;
   
2. 
   
3. class shuzup {
   
4.         public static void paixu(int[] dx) {
   
5.                 for (int x = 0; x < dx.length - 1; x++) {
   
6.                         for (int y = x + 1; y < dx.length; y++) {
   
7.                                 if (dx[x] > dx[y]) {
   
8.                                         int temp = dx[x];
   
9.                                         dx[x] = dx[y];
   
10.                                         dx[y] = temp;
    
11.                                 }
    
12.                         }
    
13.                 }
    
14.         }
    
15. 
    
16.         public static void shuzu(int[] arr) {
    
17.                 {
    
18.                         System.out.print("[");
    
19.                         for (int x = 0; x < arr.length; x++) {
    
20.                                 if (x != arr.length - 1) {
    
21.                                         System.out.print(arr[x] + ", ");
    
22.                                 } else {
    
23.                                         System.out.println(arr[x] + "]");
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.         }
    
28. 
    
29.         public static void main(String[] args) {
    
30.                 int[] dx = { 5, 1, 6, 4, 2, 8, 9 };
    
31.                 shuzu(dx);
    
32.                 paixu(dx);
    
33.                 shuzu(dx);
    
34.         }
    
35. }

复制代码

直接粘贴楼主的代码发现无法编译
是不是缺了什么东西
)
加了之后可以执行了
将数组排序，有哪里不清楚的吗

你在for(int y=x+1;y<dx.length;y++)循环后跟了；后能通过编译吗？我也编译不过呀。因为你在后面跟了；后，等到if(dx[x]>dx[y])
语句是，y已经失去它的作用范围了。而对于if(dx[x]>dx[y])中的y，它只是一个没有定义的变量，而java是强类型定义语言，变量要先定义才能再使用的。所以编译应该通不过呀！怎么能得到你说的结果呢？