public void mySort(int[] array){
                int max = 0;
                for (int i = 0; i < array.length; i++) {
                       
                        for (int j = 0; j < array.length-i-1; j++) {
                                if(array[j]>array[j+1]){
                                        max = array[j];//记住本次循环的最大值
                                }
                        }
                        change(max,array[array.length-i-1]);//最大值与最后一位交换
                }
        }

change  public void change(int offset,              
     int length,
   AbstractDocument.DefaultDocumentEvent de)
更改内容。
参数：offset - 起始偏移量，
该值 >= 0length - 长度，
该值 >= 0de - 捕获此编辑的事件

不明白你的chage方法什么意思，应该不能那么用吧！

change是自己写的方法吗？
而且你的二重循环写的也不对，
for (int i = 0; i < array.length; i++) {   这里应该是i < array.length-1;                        
                        for (int j = 0; j < array.length-i-1; j++) {  
                                if(array[j]>array[j+1]){    这里如果第0位小于第1位不就不会改变值了吗                                        max = array[j];//记住本次循环的最大值
二重循环应该一个从小到大一个从大到小的，

public void mySort(int[] array)
{
int max = 0;
for (int i = 0; i < array.length; i++)
{
                        
   for (int j = 0; j < array.length-i-1; j++)
  {
   if(array[j]>array[j+1])
   {
    max = array[j];//记住本次循环的最大值
   }
  }
  change(max,array[array.length-i-1]);//最大值与最后一位交换
}
}
楼主的思想是实现冒泡排序
根据楼主的思想 程序有两处错误
第一处：
if(array[j]>array[j+1])
{
max = array[j];//记住本次循环的最大值
}
应改为：
if(array[j]<array[j+1])
{
max = array[j+1];//记住本次循环的最大值
}
因为 如果if(array[j]>array[j+1])时max = array[j];
如果数组的最后一个值是最大时，该条件实现不了判断，
因此数组最后一个值参与比较有误，应改为上述代码
第二处：
int max = 0;应定义在外循环和内循环之间
for (int i = 0; i < array.length; i++)
{
                int max = 0;        
   for (int j = 0; j < array.length-i-1; j++)
  {
因为内循环第一次循环结束后记录的是整个数组中的最大值
以后不管内循环在怎么比较 max的值记录的永远是数组中的最大值
因此max没有及时初始化
如果考虑到每次循环都定义一个max；浪费内存空间，消耗资源
也可以将max变量定义在外循环外 在内循环每次结束后重新赋初值0即可
即该语句后：
change(max,array[array.length-i-1]);//最大值与最后一位交换
max=0;

1. public void mySort(int[] array) {
   
2.                 int max = 0;
   
3.                 for (int i = 0; i < array.length - 1; i++) {
   
4. 
   
5.                         for (int j = 0; j < array.length - i - 1; j++) {
   
6.                                 if (array[j] > array[j + 1]) {
   
7.                                         max = array[j];// 记住本次循环的最大值
   
8.                                         array[j] = array[j + 1];
   
9.                                         array[j + 1] = max;
   
10.                                 }
    
11.                         }
    
12.                         // change(max,array[array.length-i-1]);//最大值与最后一位交换
    
13.                 }
    
14.         }

复制代码

首先lz，你的这个排序小程序，并不需要定义max变量，即便在chang()     时，交换的不应该是max，而是数组内部的元素。
其次，随着排序的进行，max保存的值将会越来越小，因为每排序一次，较大值都沉淀一次，而max这次保存的值会覆盖上一次的值，造成max的值到最后在越来越小。
再之，即便用max来实现交换，那么交换前的数组元素array[array.length-i-1]，有没有在交换后被存放到数组中？
交换时，只需数组内部的两个元素交换即可。。。。。

这是我改的，希望有帮助：
public static void main(String[] args){
                int[] ar = {23,8,98,83,1};
                mySort(ar);
                printArray(ar);     //输出：[1, 8, 23, 83, 98]               
}        
public static void mySort(int[] array)
{
        //int max = 0;
        for (int i = 0; i < array.length-1; i++)
        {         
                for (int j = 0; j < array.length-i-1; j++)
                {
                        if(array[j]>array[j+1]){
                                //max = array[j];//记住本次循环的最大值
                                change(array,j,j+1);//交换一次
                                //System.out.println(max); 可以用输出来查看
                        }
                }         
        }
        //System.out.println(max);
}
        
private static void change(int[] array,int i, int j) {        //交换位置
                // TODO Auto-generated method stub
                int temp = array;
                array = array[j];
                array[j] = temp;        
}
public static void printArray(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 void mySort(int[] array){
            int max = 0;
           for (int i = 0; i < array.length; i++) {
                           if(array[i]>array[max]){
                                   max = i;      //把元素中的最大值的数组角标值赋值给max；
                           }
                   }
                 System.out.println(array[max]);   //输出元素中的最大值。
                }