1.数组排序(数字)
1.Arrays类中的sort()方法
在Java中sort()方法是Arrays类的静态方法，用于数组排序，简单好用。
是由小到大排序的：
import java.util.Arrays;
public class Example {
public static void main(String[] args) {
int []a= {3,16,8,21,15,4,2,7};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
输出结果：
[2, 3, 4, 7, 8, 15, 16, 21]
public void Sort2(String str){
char[] chs = str.toCharArray();
System.out.println("原：");
System.out.println(chs);
Arrays.sort(chs);
System.out.println("排序后：");
System.out.println(chs);
}
运行结果：
原：
to good too no string and now
排序后：
addgginnnnooooooorstttw
2.排序算法
排序算法有冒泡排序，选择排序，快排，计数排序，桶排序等。下边是冒泡排序：
public class Example {
public static void main(String[] args) {
int []arr= {3,16,8,21,15,4,2,7};
for(int i=0;i<arr.length;i++) {
for(int j=i+1;j<arr.length;j++) {
if(arr[i] > arr[j]) {
Object tmp = arr[j];
arr[j]=arr[i];
arr[i]=(int) tmp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
输出结果：
[2, 3, 4, 7, 8, 15, 16, 21]
2. 数组排序（字符串/对象）
对数字进行排序较为简单，那如果是对象和字符串怎样排序呢？可以想办法将对象和字符串转变为数字的形式，即采用哈希算法计算对象的哈希值。
hashCode()
1.字符串：
字母的hash值是它的ASCII码；
相同字符串的hash值相同，不同字符串则不同。
String str = new String("a");
System.out.println(str.hashCode());
String str = new String("abc");
System.out.println(str.hashCode());
String str2 = new String("bac");
System.out.println(str2.hashCode());
String str3 = new String("bac");
System.out.println(str3.hashCode());
结果：
97
96354
97284
97284
2.对象：
在创建对象的类型一致时，哈希值不相等，但如果对象重写了equal方法，同时重写了hashcode，对象的哈希值相等。
import java.util.Objects;
public class Example {
public static void main(String[] args) {
Object o = new Object();
System.out.println(o.hashCode());
Object o1 = new Object();
System.out.println(o1.hashCode());
User user = new User();
System.out.println(user.hashCode());
User user1 = new User();
System.out.println(user1.hashCode());
}
}
class User{
String name;
int id;
String pwd;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
User user = (User) o;
return id == user.id && Objects.equals(name, user.name) &&
Objects.equals(pwd, user.pwd);
}
@Override
public int hashCode() {
return Objects.hash(name, id, pwd);
}
}
运行结果：
366712642
1829164700
29791
29791
3. 代码实现排序
public void Sort(){
for(int i = 0; i<arrvalue.length; i++) {
for (int j = i+1; j<arrvalue.length; j++) {
int x=arrvalue[i].hashCode();
int y=arrvalue[j].hashCode();
if(x>y) {
Object temp = arrvalue[i];
arrvalue[i] = arrvalue[j];
arrvalue[j] = temp;
}
}
}
System.out.println("排序后：");
System.out.println(Arrays.toString(arrvalue));
}
3. 数组队列实现
代码：
import java.util.Arrays;
public class MyArrayList implements List{
int size;
int length;
Object[] arrvalue;
final int dflength=20;
public int getSize() {
return size;
}
public int getLength() {
return length;
}
public MyArrayList() {
length=dflength;
arrvalue=new Object[length];
size=0;
}
@Override
public void initList() {
length=dflength;
arrvalue=new Object[length];
size=0;
}
public MyArrayList(int l) {
if(l<0) {
System.err.println("存在错误：长度参数小于零");
}
if(l>=Integer.MAX_VALUE) {
System.err.println("存在错误：长度参数大于上限");
}
if(l<=dflength) {
initList();
}
if(l>dflength) {
length=l;
arrvalue=new Object[length];
size=0;
}
System.out.println("初始化长度成功");
}
@Override
public void growl() {
int oldl=length;
int newl=(oldl>>1)+oldl;
length=newl;
Object[] newArr=new Object[length];
for(int i=0;i<arrvalue.length;i++) {
newArr[i]=arrvalue[i];
}
arrvalue=newArr;
newArr=null;
System.out.println("扩容后长度："+getLength());
System.out.println("扩容后元素个数："+getSize());
}
@Override
public void add(Object value) {
if(size>=length){
growl();
}
arrvalue[size++]=value;
test();
}
@Override
public void sub(int size1) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
int newl=length-1;
length=newl;
Object[] newArr=new Object[length];
int j=0;
for(int i=0;i<arrvalue.length;i++) {
if(i!=size1) {
newArr[j]=arrvalue[i];
j++;
}
}
size--;
arrvalue=newArr;
newArr=null;
System.out.println("删除元素后：");
test();
}
@Override
public void sub2(Object value) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value) {
sub(i);
}
}
}
@Override
public Object find(int size1) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
return arrvalue[size1];
}
@Override
public void find2(Object value) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value) {
find(i);
}
}
}
@Override
public void change(int size1,Object value) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
arrvalue[size1]=value;
System.out.println("修改元素后：");
test();
}
@Override
public void change2(Object value1,Object value2) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value1) {
arrvalue[i]=value2;
}
}
}
public void Sort(){
for(int i = 0; i<arrvalue.length; i++) {
for (int j = i+1; j<arrvalue.length; j++) {
int x=arrvalue[i].hashCode();
int y=arrvalue[j].hashCode();
if(x>y) {
Object temp = arrvalue[i];
arrvalue[i] = arrvalue[j];
arrvalue[j] = temp;
}
}
}
System.out.println("排序后：");
test();
}
public void test() {
System.out.println(Arrays.toString(arrvalue));
}
}
4.泛型
类型限制是在创建对象时限制操作的类型。为了要存储的元素/变量可以灵活指定数据类型，引入了泛型。
格式：<英文字母>
如：
泛型方法：类名后添加泛型标识（<T…>），来表示该类持有的一种类型。
泛型理解：当代码相同，输入的数据会用到不同的类型时，可以用泛型（往往是一个英文字母）来替换数据类型，但是在使用时要指定类型，泛型其实可以理解为模板。泛型与通配符的区别是泛型是具体类型，而把通配符<?>是未知类型。所以，如果要对参数做修改的操作就必须要使用泛型，而仅仅查看则使用通配符。
使用泛型后代码：
接口：
public interface List<E> {
public void initList();
public void growl();
public void add(E value);
public void sub(int size1);
public void sub2(E value);
public E find(int size1);
public void find2(E value);
public void change(int size1,E value);
public void change2(E value1,E value2);
public void Sort();
}
import java.util.Arrays;
public class Example1<E> implements List<E>{
int size;
int length;
Object[] arrvalue;
final int dflength=20;
public int getSize() {
return size;
}
public int getLength() {
return length;
}
public Example1() {
length=dflength;
arrvalue=new Object[length];
size=0;
}
@Override
public void initList() {
length=dflength;
arrvalue=new Object[length];
size=0;
}
public Example1(int l) {
if(l<0) {
System.err.println("存在错误：长度参数小于零");
}
if(l>=Integer.MAX_VALUE) {
System.err.println("存在错误：长度参数大于上限");
}
if(l<=dflength) {
initList();
}
if(l>dflength) {
length=l;
arrvalue=new Object[length];
size=0;
}
System.out.println("初始化长度成功");
}
@Override
public void growl() {
int oldl=length;
int newl=(oldl>>1)+oldl;
length=newl;
Object[] newArr=new Object[length];
for(int i=0;i<arrvalue.length;i++) {
newArr[i]=arrvalue[i];
}
arrvalue=newArr;
newArr=null;
System.out.println("扩容后长度："+getLength());
System.out.println("扩容后元素个数："+getSize());
}
@Override
public void add(E value) {
if(size>=length){
growl();
}
arrvalue[size++]=value;
test();
}
@Override
public void sub(int size1) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
int newl=length-1;
length=newl;
Object[] newArr=new Object[length];
int j=0;
for(int i=0;i<arrvalue.length;i++) {
if(i!=size1) {
newArr[j]=arrvalue[i];
j++;
}
}
size--;
arrvalue=newArr;
newArr=null;
System.out.println("删除元素后：");
test();
}
@Override
public void sub2(E value) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value) {
sub(i);
}
}
}
@Override
public E find(int size1) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
E e = (E)arrvalue[size1];
return e;
}
@Override
public void find2(E value) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value) {
find(i);
}
}
}
@Override
public void change(int size1,E value) {
if(size1<0||size1>=length) {
System.err.println("存在错误：下标范围不对");
}
arrvalue[size1]=value;
System.out.println("修改元素后：");
test();
}
@Override
public void change2(E value1,E value2) {
for(int i=0;i<length;i++) {
if(arrvalue[i]==value1) {
arrvalue[i]=value2;
}
}
}
@Override
public void Sort(){
for(int i = 0; i<arrvalue.length; i++) {
for (int j = i+1; j<arrvalue.length; j++) {
int x=arrvalue[i].hashCode();
int y=arrvalue[j].hashCode();
if(x>y) {
Object temp = arrvalue[i];
arrvalue[i] = arrvalue[j];
arrvalue[j] = temp;
}
}
}
System.out.println("排序后：");
test();
}
public void test() {
System.out.println(Arrays.toString(arrvalue));
}
}
问题：在代码（1）处，已经强制转换，仍有Type safety: Unchecked cast from Object to E提示，即类型安全：未选中从对象强制转换为E。
|