两个数的转化
class TestSwap{
public int data;
}
public class TestDemo {
public static void swap(int a,int b) {
int tmp=a;
a = b;
b = tmp;
}
public static void swap2(TestSwap a,TestSwap b) {
int tmp = a.data;
a.data = b.data;
b.data = tmp;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 10;
int b = 20;
swap(a,b);
System.out.println(a);
System.out.println(b);
System.out.println("===================");
TestSwap t = new TestSwap();
t.data = 10;
TestSwap t2 = new TestSwap();
t2.data = 20;
swap2(t,t2);
System.out.println(t.data);
System.out.println(t2.data);
}
}
由此可见:简单的swap方法是不能将两个数转换的
原因:
数组的遍历
int[] array = {1,2,3,4,5,6,7,8,9};
int[] array2 = new int[]{1,2,3,4,5};
int[] array3 = new int[10];
三个数组的存储方法:
数组输出的两种方法
public static void show(int[] array){
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1,2,3,4,5,6,7,8,9};
for(int j:array)
{
System.out.println(j);
}
}
用数组输出Fibonacci前40项:
public class lll {
public static void show(int[] array){
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void Fibonacci(int[] array){
array[0] = 1;
array[1] = 1;
for(int i=3;i<=array.length;i++)
{
array[i] = array[i-1]+array[i-2];
System.out.println(array[i]);
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = new int[40];
Fibonacci(array);
show(array);
}
}
数组的4种拷贝方式
(1)for循环拷贝
基本类型
public class TestDemo3 {
public static void show(int[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1,2,3,4,5};
int[] array2 = new int[array.length];
for(int i = 0;i<array.length;i++)
{
array2[i] = array[i];
}
show(array);
System.out.println("---------");
show(array2);
array2[0]=100;
System.out.println("----改变后-----");
show(array);
System.out.println("---------");
show(array2);
}
}
改变了array2的值,array的值并没有改变,我们称此拷贝为深拷贝;
引用类型
class TestArray{
private int val = 10;
public int getVal(){ //得到val值
return val;
}
public void setVal(int val){ //设置val值
this.val = val;
}
}
public class TestDemo3 {
public static void show2(TestArray[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i].getVal());
}
System.out.println();
}
public static void main(String[] args) {
TestArray[] t1 = new TestArray[3];
t1[0] = new TestArray();
t1[1] = new TestArray();
t1[2] = new TestArray();
TestArray[] t2 = new TestArray[3];
for(int i=0;i<t1.length;i++)
{
t2[i] = t1[i];
}
show2(t1);
System.out.println("------");
show2(t2);
System.out.println("---改变后---");
t2[0].setVal(1000);
show2(t1);
System.out.println("--------");
show2(t2);
}
这不仅改变了t2的值,t1的值也发生了改变;
若改变一个值,则t1以及t2的值都会改变,我们称此类拷贝为浅拷贝;
(2)clone
基本类型
public class TestDemo4 {
public static void show(int[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1,2,3,};
int[] array2 = new int[array.length];
System.out.println(array);
System.out.println(array2);
array2 = array.clone();
show(array);
System.out.println("===========");
show(array2);
array[0] = 100;
System.out.println("=====改变后======");
show(array);
System.out.println("===========");
show(array2);
}
}
改变了array2的值,array的值并没有改变,我们称此拷贝为深拷贝;
引用类型:
class TestArray2{
private int val = 10;
public int getVal(){ //得到val值
return val;
}
public void setVal(int val){ //设置val值
this.val = val;
}
}
public class TestDemo4 {
public static void show2(TestArray2[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i].getVal());
}
System.out.println();
}
public static void main(String[] args) {
TestArray2[] t1 = new TestArray2[3];
t1[0] = new TestArray2();
t1[1] = new TestArray2();
t1[2] = new TestArray2();
TestArray2[] t2 = new TestArray2[3];
t2 = t1.clone();
show2(t1);
System.out.println("========");
show2(t2);
t2[0].setVal(100);
System.out.println("====改变后=====");
show2(t1);
System.out.println("=========");
show2(t2);
}
}
这不仅改变了t2的值,t1的值也发生了改变;
若改变一个值,t1以及t2的值都会改变,我们称此类拷贝为浅拷贝;
(3)System.arraycopy
arraycopy(object src, int srcPos,
object dest,int destPos,
int length)
src:源数组
srcPos:源数组的开始位置 0 开始拷贝的位置
dest:拷贝到目标数组
destPos: 拷贝到目标数组的位置
length:源数组 拷贝多大
基本类型
public class TestDemo5 {
public static void show(int[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1,2,3,4,5};
int[] array2 = new int[array.length];
System.arraycopy(array,0,array2,0,array.length);
show(array);
System.out.println("=========");
show(array2);
System.out.println("====改变后=====");
array2[0] = 100;
show(array);
System.out.println("=========");
show(array2);
}
}
改变了array2的值,array的值并没有改变,我们称此拷贝为深拷贝;
引用类型
class TestArray3{
private int val = 10;
public int getVal(){ //得到val值
return val;
}
public void setVal(int val){ //设置val值
this.val = val;
}
}
public class TestDemo5 {
public static void show2(TestArray3[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i].getVal());
}
System.out.println();
}
public static void main(String[] args) {
TestArray3[] t1 = new TestArray3[3];//引用类型
t1[0] = new TestArray3();
t1[1] = new TestArray3();
t1[2] = new TestArray3();
TestArray3[] t2 = new TestArray3[3];
System.arraycopy(t1,0,t2,0,t1.length);
show2(t1);
System.out.println("========");
show2(t2);
t2[0].setVal(10000);
System.out.println("====改变后=====");
show2(t1);
System.out.println("======");
show2(t2);
}
}
这不仅改变了t2的值,t1的值也发生了改变;
若改变一个值,则t1以及t2的值都会改变,我们称此类拷贝为浅拷贝;
(4)Arrays.copyOf()
- Arrays.copyOf();
- Arrays:工具类 数组 包含许多方法
- T[] original(原始数组 ),int newLength(新的数组长度)
基本类型
public class TestDemo6 {
public static void show(int[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {1,2,3,4};
int[] array2 = new int[array.length];
array2 = Arrays.copyOf(array, array2.length);
show(array);
System.out.println("=========");
show(array2);
System.out.println("=====改变后哦====");
array2[0] = 1000;
show(array);
show(array2);
}
}
改变了array2的值,array的值并没有改变,我们称此拷贝为深拷贝;
引用类型
class TestArray4{
private int val = 10;
public int getVal(){ //得到val值
return val;
}
public void setVal(int val){ //设置val值
this.val = val;
}
}
public class TestDemo6 {
public static void show2(TestArray4[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i].getVal());
}
System.out.println();
}
public static void main(String[] args) {
TestArray4[] t1 = new TestArray4[3];//引用类型
t1[0] = new TestArray4();
t1[1] = new TestArray4();
t1[2] = new TestArray4();
TestArray4[] t2 = new TestArray4[3];
t2 = Arrays.copyOf(t1, t2.length);
show2(t1);
System.out.println("========");
show2(t2);
t2[0].setVal(100);
System.out.println("====改变后=====");
show2(t1);
System.out.println("======");
show2(t2);
}
}
这不仅改变了t2的值,t1的值也发生了改变;
若改变一个值,则t1以及t2的值都会改变,我们称此类拷贝为浅拷贝;
冒泡排序法
public class TestDemo7 {
public static void show(int[] array) {
for(int i=0;i<array.length;i++)
{
System.out.println(array[i]+" ");
}
System.out.println();
}
public static void bubbleSort(int[] array){
System.out.println(System.currentTimeMillis());
int tmp = 0;
for(int i=0;i<array.length-1;i++){
for(int j=0;j<array.length-1-i;j++){
if(array[j]>array[j+1]){
tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
}
}
}
System.out.println(System.currentTimeMillis());
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {12,43,2,1,54,76};
bubbleSort(array);
show(array);
}
}