精华内容
下载资源
问答
  • oracle常用函数

    千次阅读 2019-04-24 14:58:43
    GREATEST(express_1, express_2, .....在比较时,OracIe会自动按表达式的数据类型进行比较,以express_1的数据类型为准,其后表达式数据类型先隐式转换为表达式express_1的数据类型再比较。如果存在无法隐式转换的,...

    GREATEST(express_1, express_2, ...express_n)函数从表达式(列、常量、计算值)express_1, express_2, ... express_n等中找出最大的数返回。在比较时,OracIe会自动按表达式的数据类型进行比较,以express_1的数据类型为准,其后表达式数据类型先隐式转换为表达式express_1的数据类型再比较。如果存在无法隐式转换的,则报错。express_1, express_2, ...express_n中存在null返回null

    NAL()

    作用:判断某个值是否为空值,若不为空值则输出,若为空值,返回指定值。

    详细解释如下:

    1、nvl()函数的格式如下:NVL(expr1,expr2);

    2、含义是:如果oracle第一个参数为空那么显示第二个参数的值,如果第一个参数的值不为空,则显示第一个参数本来的值。

     nvl(nvl(greatest(s.l_max, s.r_max),

                   greatest(s1.l1_max,

                            s1.l2_max,

                            s1.l3_max,

                            s1.l4_max,

                            s1.l5_max,

                            s1.l6_max)),

               a."TEMPERATURE") TEMPERATURE,

    decode(条件,值1,返回值1,值2,返回值2,…值n,返回值n,缺省值)
    这个是decode的表达式,具体的含义解释为:
    IF 条件=值1 THEN
    RETURN(翻译值1)
    ELSIF 条件=值2 THEN
    RETURN(翻译值2)
    ......
    ELSIF 条件=值n THEN
    RETURN(翻译值n)
    ELSE
    RETURN(缺省值)
    END IF

    decode(b.belong,'01',f.stocknum,'02',f.stocknum,0))

     

    展开全文
  • 枚举类特点 枚举类很安全,不能被实例化对象,甚至用反射... 所有的枚举类都有静态方法:valuesOf可以将String类型的字符串转换为枚举类型的对象; 枚举常量必须最先声明,并且常量之间需要用逗号隔开,最后一个常...

    枚举类特点

    1. 枚举类很安全,不能被实例化对象,甚至用反射都无法创建对象;
    2. 可以使用name()和oridnal()方法来返回枚举对象的实例名称和序数(从0开始);
    3. 所有的枚举类都有静态方法:values可以获取当前枚举类中的所有实例;
    4. 所有的枚举类都有静态方法:valuesOf可以将String类型的字符串转换为枚举类型的对象;
    5. 枚举常量必须最先声明,并且常量之间需要用逗号隔开,最后一个常量用分号;
    6. 枚举常量之后若使用{},则表示当前枚举类的匿名内部类;
    7. 使用switch操作枚举。
    public class EnumDemo {
    	public static void main(String[] args) {
    		//用Integer表示星期几业务含义不明确
    		Employee e = new Employee();
    		e.setRestDay(WeekDay.SUN);
    		
    		if (e.getRestDay() == WeekDay.SAT || e.getRestDay() == WeekDay.SUN)
    			System.out.println("周末休息");
    		else System.out.println("周一到周五休息");
    		System.out.println("-------------------------");
    		System.out.println(WeekDay.SAT.name());
    		System.out.println(WeekDay.SAT.ordinal());
    		System.out.println("-------------------------");
    		WeekDay[] days = WeekDay.values();
    		for (WeekDay day : days){
    			System.out.println(day);
    		}
    		
    		System.out.println("-------------------------");
    		WeekDay day = WeekDay.valueOf("SUN");
    		System.out.println(day);
    	}
    }

    在枚举类中,底层操作就是创建一个一个的对象的实例: 

    public class WeekDay2 {
    	public static final WeekDay2 MON= new WeekDay2();//Monday
    	public static final WeekDay2 TUE= new WeekDay2();//Tuesday
    	public static final WeekDay2 WED= new WeekDay2();//Wednesday
    	public static final WeekDay2 THU= new WeekDay2();//Thursday
    	public static final WeekDay2 FRI= new WeekDay2();//Friday
    	public static final WeekDay2 SAT= new WeekDay2();//Saturday
    	public static final WeekDay2 SUN= new WeekDay2();//Sunday
    	
    	//防止创建新的对象
    	private WeekDay2(){}//实际上枚举类Enum中并没有无参数构造器,
                                //只有一个带有String和int的构造器,分别表示枚举对象的名称和序数
    	
    }

    Lambda表达式

    基本语法:参数列表->表达式

    1. 参数列表
      1. 如果没有参数,直接用()表示,()不能省略;
      2. 如果只有一个参数,并且参数写了类型,参数外面一定要加();
      3. 如果只有一个参数,并且参数不写类型,这个参数外面可以不用加();
      4. 如果有两个及以上的参数,不管书否写参数类型,都必须加();
      5. 如果参数要加修饰符或者标签,参数一定要加上完整的类型;
      public class LambdaTest1 {
      	class User {
      		public String name;
      		public int score;
      
      		@Override
      		public String toString() {
      			return "User [name=" + name + ", score=" + score + "]";
      		}
      
      		public User(String name, int score) {
      			this.name = name;
      			this.score = score;
      		}
      	}
      
      	@Test
      	public void testOldUse1() {
      		User[] us = new User[] { new User("张三", 90), new User("李四", 95),
      				new User("王五", 98) };
      		//sort
      		Arrays.sort(us, new Comparator<User>() {
      
      			@Override
      			public int compare(User o1, User o2) {
      				return Integer.compare(o1.score, o2.score);
      			}
      
      		});
      		System.out.println(Arrays.toString(us));
      	}
      
      	@Test
      	public void testNewUse1() {
      		User[] us = new User[] { new User("张三", 90), new User("李四", 95),
      				new User("王五", 98) };
      		//sort
      		//Lambda表达式
      		Arrays.sort(us, (User o1, User o2) -> {
      			return Integer.compare(o1.score, o2.score);
      		});
      		System.out.println(Arrays.toString(us));
      	}
      
      	@Test
      	public void testNewUse2() {
      		User[] us = new User[] { new User("张三", 90), new User("李四", 95),
      				new User("王五", 98) };
      		//sort
      		//Lambda表达式
      		Arrays.sort(us,
      				(User o1, User o2) -> Integer.compare(o1.score, o2.score));
      		System.out.println(Arrays.toString(us));
      	}
      
      	@Test
      	public void testNewUse3() {
      		User[] us = new User[] { new User("张三", 90), new User("李四", 95),
      				new User("王五", 98) };
      		//sort
      		//Lambda表达式
      		Arrays.sort(us, (o1, o2) -> Integer.compare(o1.score, o2.score));
      		System.out.println(Arrays.toString(us));
      	}
      
      	@Test
      	public void testOldUse2() {
      		new Thread(new Runnable() {
      
      			@Override
      			public void run() {
      				System.out.println("Hello Lambda");
      			}
      		}).start();
      	}
      
      	@Test
      	public void testOldUse3() {
      		new Thread(() -> System.out.println("Hello Lambda")).start();
      	}
      
      	@Test
      	public void testOldUse4() {
      		Runnable run = new Runnable() {
      
      			@Override
      			public void run() {
      				System.out.println("Hello Lambda!");
      			}
      		};
      		new Thread(run).start();
      	}
      	
      	@Test
      	public void testNewUse5() {
      		Runnable run = () -> System.out.println("Hello Lambda!");
      		new Thread(run).start();
      		new Thread(run).start();
      	}
      }
    2. 表达式
      1. 如果表达式只有一行,那么可以直接写,不需要加{};
      2. 如果表达式有多行,需要用代码块{}表示;
      3. 如果表达式是代码块,并且需要返回值,那么在代码块中必须返回一个返回值;
      4. 如果只有单行的情况下,并且方法需要返回值,这时不能有return,编译器会自动帮我们推导return;
    public class LambdaTest2 {
    
    	@Test
    	public void test1() {
    		new Thread(() -> System.out.println("Hello Lambda")).start();
    	}
    
    	public static void main(String[] args) {
    		Frame f = new Frame();
    		f.setSize(100, 100);
    		Button btn = new Button("lambda");
    		btn.addActionListener(e -> System.out.println("Lambda"));
    		f.add(btn);
    		f.setVisible(true);
    	}
    
    	@Test
    	public void test2() {
    		String[] strs = new String[] { "Lambdalalala", "Cherry", "Bubbui",
    				"BBC" };
    
    		Arrays.sort(strs, (final String s1, final String s2) -> {
    			if (s1 != null && s2 != null)
    				return Integer.compare(s1.length(), s2.length());
    			return -1;
    		});
    		System.out.println(Arrays.toString(strs));
    	}
    }

    lambda表达式中的变量

    1. 参数;
    2. 局部变量;
    3. 自由变量(既不是参数也不是局部变量)

    结论:lambda表达式中的自由变量会被保存,无论什么时候执行lambda表达式,都可以直接使用。

    1. 自由变量在lambda表达式中不能被修改(在底层已经被用final修饰);(操作自由变量的代码块,称为闭包)
    2. 参数和局部变量的使用方式和普通的变量使用方式相同;
    3. lambda表达式中的this指向创建lambda表达式的方法中的this;
    public class LambdaTest3 {
    
            /**
    	 * lambda表达式中this指向创建lambda表达式的方法中的this
    	 * @param content
    	 * @param times
    	 */
    	
    	public void repeatPrint(String content, int times) {
    		System.out.println(this);//com.Bryan._06_lambda.LambdaTest3@514713
    		Runnable run = ()->{
    			System.out.println(this);//com.Bryan._06_lambda.LambdaTest3@514713
    		};
    		new Thread(run).start();
    	}
    	
    	public void repeatPrint2(String content, int times) {
    		Runnable run = new Runnable(){
    
    			@Override
    			public void run() {
    				System.out.println(this);//com.Bryan._06_lambda.LambdaTest3$1@145df5f
    			}
    			
    		};
    		new Thread(run).start();
    	}
    	
    	@Test
    	public void testVar(){
    		this.repeatPrint("Hello", 5);
    	}
    }

    函数式接口

    1. 我们能够写lambda表达式的地方:一个接口,且里面只有一个抽象方法;
    2. 在Java中,把只有一个抽象方法的接口称为函数式接口,如果一个接口是函数式接口,我们可以在接口上添加@functionalInterface标签,表明这是一个函数式接口;(检查,文档)
       
    3. 无论是否标识@functionalInterface,只要满足函数式接口的接口,Java都会识别为函数式接口;
    4. 简化函数式接口的使用是JAVA中提供lambda表达式唯一的作用;
    5. 可以用接口直接引用一个lambda表达式;
    6. 函数式接口里可以写Object对象中的方法;
    7. lambda表达式中的异常处理:lambda表达式中产生的异常要么直接在代码块中处理,要么在接口的方法声明抛出。
    public class LambdaTest4{
    	
    	public void wrapWork(IMyWork work){
    		System.out.println("Do some wrap work...");
    		try {
    			work.dowork();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	@Test
    	public void test() throws Exception{
    		IMyWork work = () -> {
    			System.out.println("haha");
    			Thread.sleep(1000);
    		};
    		this.wrapWork(work);
    	}
    }
    @FunctionalInterface
    public interface IMyWork {
    
    	void dowork() throws Exception;
    	
    	boolean equals(Object o);
    }
    

    方法引用

    1. 类::静态方法
    2. 对象::方法
    3. 对象::静态方法
    public class LambdaTest5 {
    
    	@Test
    	public void test1() {
    		Integer[] is = new Integer[]{2,2,8,4,1,4,7,3};
    		//Arrays.sort(is,(x,y) -> Integer.compare(x, y));
    		//也是lambda表达式,方法引用(类::静态方法)
    		Arrays.sort(is,Integer::compare);
    		System.out.println(Arrays.toString(is));	
    	}
    	
    	public int compare(int x,int y){
    		return Integer.compare(x, y);
    	}
    	
    	@Test
    	public void test2(){
    		LambdaTest5 lt = new LambdaTest5();
    		Integer[] is = new Integer[]{2,2,8,4,1,4,7,3};
    		//方法引用(对象::方法)
    		//Arrays.sort(is,lt::compare);
    		//Arrays.sort(is,this::compare);
    		List<Integer> list =Arrays.asList(2,2,8,4,1,4,7,3);
    		//list.forEach(x->System.out.println(x));
    		list.forEach(System.out::println);
    		//System.out.println(Arrays.toString(is));
    	}
    }

    构造器引用(需要一个无参构造方法)

    1. 类::new
    2. 构造器引用对应的函数式接口里面的方法格式一定是:返回一个对象/方法没有参数
    public class LambdaTest5 {
    
    	@Test
    	public void test1() {
    		Integer[] is = new Integer[] { 2, 2, 8, 4, 1, 4, 7, 3 };
    		//Arrays.sort(is,(x,y) -> Integer.compare(x, y));
    		//也是lambda表达式,方法引用(类::静态方法)
    		Arrays.sort(is, Integer::compare);
    		System.out.println(Arrays.toString(is));
    	}
    
    	public int compare(int x, int y) {
    		return Integer.compare(x, y);
    	}
    
    	@Test
    	public void test2() {
    		LambdaTest5 lt = new LambdaTest5();
    		Integer[] is = new Integer[] { 2, 2, 8, 4, 1, 4, 7, 3 };
    		//方法引用(对象::方法)
    		//Arrays.sort(is,lt::compare);
    		//Arrays.sort(is,this::compare);
    		List<Integer> list = Arrays.asList(2, 2, 8, 4, 1, 4, 7, 3);
    		//list.forEach(x->System.out.println(x));
    		list.forEach(System.out::println);
    		//System.out.println(Arrays.toString(is));
    	}
    
    	public <T> List<T> asList(IMyCreator<List<T>> creator, T... a) {
    		List<T> list = creator.create();
    		for (T t : a)
    			list.add(t);
    		return list;
    	}
    
    	@Test
    	public void test3() {
    		//构造方法引用
    		//类::new
    		//List<Integer> list = Arrays.asList(2, 2, 8, 4, 1, 4, 7, 3);
    		List<Integer> list = this.asList(() -> {return new ArrayList();} , 2, 2, 8, 4);
    		List<Integer> list2 = this.asList(ArrayList::new , 2, 2, 8, 4);
    		list.forEach(System.out::println);
    		System.out.println(list.getClass());
    	}
    }

    接口的默认方法

    1. 可以实现多继承;
    2. 解决冲突:
      1. 如果两个接口中有相同方法签名的默认方法,子类必须实现冲突的方法,指定使用某一个父接口中的默认实现;
      2. 如果父类里面有何接口中一个默认方法有相同的方法签名,那么使用父类里的方法;
      3. 永远不要期望用接口里面的默认方法来改变Object对象里面的方法;
    3. 接口里面可以直接写接口的静态方法了;
    4. 常见的一些模式被取代
      1. 工具类
      2. 适配器模式
    展开全文
  • //转换不成功时按域名解析 if( ulDestIP == INADDR_NONE ) { hostent * pHostent = gethostbyname( IpAddress ); if( pHostent ) { ulDestIP = ( *( in_addr* )pHostent->h_addr).s_addr; } else ...
  • 字符串String是个常量,其对象一旦创建完毕就无法该改变,使用“+”进行拼接时,是生成了一个新的String对象,而不是向原有的String对象追加内容。字符串与任何其他原生数据类型变量相“+”,其他都先转换为字符串,...

    字符串String是个常量,其对象一旦创建完毕就无法该改变,使用“+”进行拼接时,是生成了一个新的String对象,而不是向原有的String对象追加内容。字符串与任何其他原生数据类型变量相“+”,其他都先转换为字符串,然后相加。

    StringBuffer初始化有16个字符长度,append()方法返回StringBuffer对象本身,toString()方法返回一个字符串。

    1、包装类(Wrapper Class)。针对原生数据类型的包装。所有的包装类(8个)都位于Java.lang包下。java中8个包装类分别是:Byte类、Short类、Long类、Float类、Double类、Character类和Boolean类。可以实现原生数据类型与包装类的双向转换。

    2、数组(Array):相同类型数据的集合就叫做数组。如何定义数组:

    type[] 变量名 = new type[数组中元素的个数];   或者   type 变量名[] = new type[]

    int[]  a = new int[4];      int a[] = int[4];

    数组中的元素索引是从0开始的,对于数组来说,最大的索引== 数组长度-1;

    [java] view plain copy
    1. 数组的三种定义与初始化:  
    [java] view plain copy
    1. public class ArrayTest  
    2. {  
    3.     public static void main(String[] args)  
    4.     {  
    5.         int[] a = new int[4];  
    6.           
    7.         a[0] = 1;  
    8.         a[1] = 2;  
    9.         a[2] = 3;  
    10.         a[3] = 4;  
    11.   
    12.         System.out.println(a[3]);  
    13.   
    14.         int b[] = new int[2];  
    15.   
    16.         b[0] = 1;  
    17.         b[1] = 2;  
    18.   
    19.         int[] c = {1,2,3,4};  
    20.   
    21.         System.out.println(c[2]);  
    22.   
    23.         int[] d = new int[]{1,2,3,4};  
    24.   
    25.     }  
    26. }  


     3、java中每个数组都有一个length属性,表示数组的长度。length属性是public ,final,int的。数组长度一旦确定,就不能改变大小。

    [java] view plain copy
    1. int[] a = new int[4];  
    2. a.lenght = 6;         //错误,length无法改变  
    3. int[] b = new int[4];  
    4. System.out.println(a[0]);   //打印0  


    没有赋初值,使用默认值。数组元素在内存中是连续存放的

    int[] a = new int[10],其中a是一个引用,它指向了生成的数组对象的首地址,数组中每一个元素都是int类型,其中仅存放数据值本身。 

    4、当是一个引用类型的数组时,假定定义了一个Person类,定义一个Person数组:Person[]  p = new Person[3];

    5、二维数组:二维数组是一种平面的二维结构。本质上是数组的数组。二维数组的定义方式:

    Type[][] a = new type[2][3];

    java允许定义不规整的二维数组。 

    int [][] a = new int[3][];

    a[0] = new int[2];

    a[1] = new int[3];

    a[2] = new int[1];

    二维数组初始化:

    int[][] a = new int[][]{{1,2,3}{4,5}{6,7,8,9}};

    6、关于交换

    [java] view plain copy
    1. public class Swap1  
    2. {  
    3.     public static void swap(char[] ch,char c)  
    4.     {  
    5.         ch[0] = 'B';  
    6.         c ='D';  
    7.     }  
    8.   
    9.     public static void swapInt(int[] i)  
    10.     {  
    11.         int temp = i[0];  
    12.         i[0] = i[1];  
    13.         i[1] = temp;  
    14.     }  
    15.     public static void main(String[] args)  
    16.     {  
    17.         char[] ch ={'A','C'};  
    18.   
    19.         Swap1.swap(ch,ch[1]);  
    20.   
    21.         for(int i = 0;i < ch.length;i++)  
    22.         {  
    23.           
    24.         System.out.println(ch[i]);  
    25.         }  
    26.   
    27.         int[] i ={1,2};  
    28.   
    29.         Swap1.swapInt(i);  
    30.           
    31.         for(int j = 0;j < i.length;j++)  
    32.         {  
    33.           
    34.         System.out.println(i[j]);  
    35.         }  
    36.   
    37.     }  
    38. }  


    7、如果定义了一个接口  interface I  {}

    则I[] i = new I[2];是正确的。

    8、java.util.Arrays类提供了大量数组方法共使用,这些方法都是静态的(static),可以直接通过类名加点的形式使用,就是Arrays.methods()方式使用。

    9、java.lang.System类提供了很多静态数组方法,如arraycopy()等。

    10、三维数组:int[][][] a = new int[2][3][4];

    11、冒泡排序

    [java] view plain copy
    1. public class BollList  
    2. {  
    3.     public static void bollList(int[] a)  
    4.     {  
    5.         for(int i = 0; i < a.length-1; i++)  
    6.         {  
    7.             boolean change = true;  
    8.   
    9.             for(int k = 0; k < a.length - i -1; k++)  
    10.             {  
    11.                 if(a[k] > a[k+1])  
    12.                 {  
    13.                     int temp = a[k+1];  
    14.                     a[k+1] = a[k];  
    15.                     a[k] = temp;  
    16.   
    17.                     change = false;  
    18.                 }  
    19.             }  
    20.               
    21.             if(change == true)  
    22.             {  
    23.                 break;  
    24.             }  
    25.             for(int h = 0;h < a.length;h++)  
    26.             {  
    27.                 System.out.print(a[h] + "  ");  
    28.             }  
    29.             System.out.println();  
    30.               
    31.         }  
    32.     }  
    33.       
    34.     public static void main(String[] args)  
    35.     {  
    36.         int[] a = new int[]{2,4,7,9,8};  
    37.   
    38.         BollList.bollList(a);  
    39.   
    40.         for(int i = 0; i < a.length; i++)  
    41.         {  
    42.             System.out.println(a[i]);  
    43.         }  
    44.     }  
    45. }  
    展开全文
  • 字符串String是个常量,其对象一旦创建完毕就无法该改变,使用“+”进行拼接时,是生成了一个新的String对象,而不是向原有的String对象追加内容。字符串与任何其他原生数据类型变量相“+”,其他都先转换为字符串,...

    字符串String是个常量,其对象一旦创建完毕就无法该改变,使用“+”进行拼接时,是生成了一个新的String对象,而不是向原有的String对象追加内容。字符串与任何其他原生数据类型变量相“+”,其他都先转换为字符串,然后相加。

    StringBuffer初始化有16个字符长度,append()方法返回StringBuffer对象本身,toString()方法返回一个字符串。

    1、包装类(Wrapper Class)。针对原生数据类型的包装。所有的包装类(8个)都位于java.lang包下。java中8个包装类分别是:Byte类、Short类、Long类、Float类、Double类、Character类和Boolean类。可以实现原生数据类型与包装类的双向转换。

    2、数组(Array):相同类型数据的集合就叫做数组。如何定义数组:

    type[] 变量名 = new type[数组中元素的个数];   或者   type 变量名[] = new type[]

    int[]  a = new int[4];      int a[] = int[4];

    数组中的元素索引是从0开始的,对于数组来说,最大的索引== 数组长度-1;

    数组的三种定义与初始化:
    public class ArrayTest
    {
    	public static void main(String[] args)
    	{
    		int[] a = new int[4];
    		
    		a[0] = 1;
    		a[1] = 2;
    		a[2] = 3;
    		a[3] = 4;
    
    		System.out.println(a[3]);
    
    		int b[] = new int[2];
    
    		b[0] = 1;
    		b[1] = 2;
    
    		int[] c = {1,2,3,4};
    
    		System.out.println(c[2]);
    
    		int[] d = new int[]{1,2,3,4};
    
    	}
    }


     3、java中每个数组都有一个length属性,表示数组的长度。length属性是public ,final,int的。数组长度一旦确定,就不能改变大小。

    int[] a = new int[4];
    a.lenght = 6;         //错误,length无法改变
    int[] b = new int[4];
    System.out.println(a[0]);   //打印0


    没有赋初值,使用默认值。数组元素在内存中是连续存放的

    int[] a = new int[10],其中a是一个引用,它指向了生成的数组对象的首地址,数组中每一个元素都是int类型,其中仅存放数据值本身。 

    4、当是一个引用类型的数组时,假定定义了一个Person类,定义一个Person数组:Person[]  p = new Person[3];

    5、二维数组:二维数组是一种平面的二维结构。本质上是数组的数组。二维数组的定义方式:

    Type[][] a = new type[2][3];

    java允许定义不规整的二维数组。 

    int [][] a = new int[3][];

    a[0] = new int[2];

    a[1] = new int[3];

    a[2] = new int[1];

    二维数组初始化:

    int[][] a = new int[][]{{1,2,3}{4,5}{6,7,8,9}};

    6、关于交换

    public class Swap1
    {
    	public static void swap(char[] ch,char c)
    	{
    		ch[0] = 'B';
    		c ='D';
    	}
    
    	public static void swapInt(int[] i)
    	{
    		int temp = i[0];
    		i[0] = i[1];
    		i[1] = temp;
    	}
    	public static void main(String[] args)
    	{
    		char[] ch ={'A','C'};
    
    		Swap1.swap(ch,ch[1]);
    
    		for(int i = 0;i < ch.length;i++)
    		{
    		
    		System.out.println(ch[i]);
    		}
    
    		int[] i ={1,2};
    
    		Swap1.swapInt(i);
    		
    		for(int j = 0;j < i.length;j++)
    		{
    		
    		System.out.println(i[j]);
    		}
    
    	}
    }


    7、如果定义了一个接口  interface I  {}

    则I[] i = new I[2];是正确的。

    8、java.util.Arrays类提供了大量数组方法共使用,这些方法都是静态的(static),可以直接通过类名加点的形式使用,就是Arrays.methods()方式使用。

    9、java.lang.System类提供了很多静态数组方法,如arraycopy()等。

    10、三维数组:int[][][] a = new int[2][3][4];

    11、冒泡排序

    public class BollList
    {
    	public static void bollList(int[] a)
    	{
    		for(int i = 0; i < a.length-1; i++)
    		{
    			boolean change = true;
    
    			for(int k = 0; k < a.length - i -1; k++)
    			{
    				if(a[k] > a[k+1])
    				{
    					int temp = a[k+1];
    					a[k+1] = a[k];
    					a[k] = temp;
    
    					change = false;
    				}
    			}
    			
    			if(change == true)
    			{
    				break;
    			}
    			for(int h = 0;h < a.length;h++)
    			{
    				System.out.print(a[h] + "  ");
    			}
    			System.out.println();
    			
    		}
    	}
    	
    	public static void main(String[] args)
    	{
    		int[] a = new int[]{2,4,7,9,8};
    
    		BollList.bollList(a);
    
    		for(int i = 0; i < a.length; i++)
    		{
    			System.out.println(a[i]);
    		}
    	}
    }


     

    展开全文
  • 数组名不是指针

    2021-02-21 20:55:02
    数组名通常可以隐式转换为指针,表示数组第一个元素的地址,是常量无法作为左值。 在自定义函数中,如果形参中有数组,那自定义函数中的数组名就“沦落”为指针,可以作为左值,使用sizeof()运算符、&运算符...
  • 1.1.2 数据类型及其相互转换 2 1.1.3 运算符及其优先级 3 1.1.4 普通公式与数组公式 5 1.1.5 单个单元格公式与多个单元格公式 5 1.1.6 Excel对数字精度、公式与函数等方面的限制 5 1.2 输入与编辑公式 6 ...
  • 易语言 茶凉专用模块

    2010-05-04 12:26:36
    子程序 到任意进制, 文本型, 公开, 可以将从二进制到三十六进制的数值随意进行转换(返回转换后的文本) .参数 被转换文本, 文本型, , 欲被转换的文本(不可以转换负数以及小数) .参数 被转换进制, 整数型, , 被转换...
  • 3.11 隐式类型转换和强制类型转换 3.11.1 整型提升 3.11.2 寻常算术转换 3.11.3 强制类型转换 3.12 十六进制和八进制常量 3.13 总结 3.14 练习 第4章 控制流 4.1 关系操作符、相等操作符和逻辑操作符 4.2 关系操作符...
  • 最后,本章还将介绍一种更安全的方法来替代不受限制的强制类型转换。 第16章:string类和标准模板库 本章将讨论C++语言中新增的一些类库。对于传统的C-风格字符串来说,string类是一种方便且功能强大的 替代...
  • 最后,本章还将介绍一种更安全的方法来替代不受限制的强制类型转换。 第16章:string类和标准模板库 本章将讨论C++语言中新增的一些类库。对于传统的C-风格字符串来说,string类是一种方便且功能强大的 替代...
  • 最后,本章还将介绍一种更安全的方法来替代不受限制的强制类型转换。 第16章:string类和标准模板库 本章将讨论C++语言中新增的一些类库。对于传统的C-风格字符串来说,string类是一种方便且功能强大的 替代...
  • 最后,本章还将介绍一种更安全的方法来替代不受限制的强制类型转换。 第16章:string类和标准模板库 本章将讨论C++语言中新增的一些类库。对于传统的C-风格字符串来说,string类是一种方便且功能强大的 替代...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数...
  • 深入Java虚拟机

    2014-06-28 23:53:10
    第11章 类型转换 11.1 转换操作码 11.2 一个模拟:“Conversion Diversion” 11.3 随书光盘 11.4 资源页 第12章 整数运算 12.1 二进制补码运算 12.2 Inner Int:揭示Java int类型内部性质 的applet ...
  • 1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数...
  • 互联网支持库中的“FTP目录列表”命令返回的文件时间改为FTP服务器返回的原始时间,不做任何时区转换。 4. 互联网支持库中的“置代理服务器”命令增加了参数,用于支持代理服务器用户认证。 5. 修改控制台操作...
  • 第11章 类型转换 11.1 转换操作码 11.2 一个模拟:“Conversion Diversion” 11.3 随书光盘 11.4 资源页 第12章 整数运算 12.1 二进制补码运算 12.2 Inner Int:揭示Java int类型内部性质的applet ...
  • 1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数...
  • 1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数...
  • 1.22 如何声明返回指向同类型函数的指针的函数?我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数...
  • 深入java虚拟机第二版

    2010-06-22 17:15:52
    第11章 类型转换 11.1 转换操作码 11.2 一个模拟:“Conversion Diversion” 11.3 随书光盘 11.4 资源页 第12章 整数运算 12.1 二进制补码运算 12.2 Inner Int:揭示Java int类型内部性质 的applet 12.3 运算...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

无法转换常量返回类型