精华内容
下载资源
问答
  • Java创建对象详解:Java创建对象的几种方法

    万次阅读 多人点赞 2019-05-10 20:01:32
    Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建与隐含创建情况。 显式创建对象 对象的显式创建方式有 4 。 1. 使用 new 关键字创建对象 这是常用的创建...

    对象是对类的实例化。对象具有状态和行为,变量用来表明对象的状态,方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建隐含创建两种情况。

    显式创建对象

    对象的显式创建方式有 4 种。

    1. 使用 new 关键字创建对象
    这是常用的创建对象的方法,语法格式如下:
    类名 对象名=new 类名();

    2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法
    在 Java 中,可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象,代码格式如下:
    java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);
    类名 对象名=(类名)Class类对象名称.newInstance();

    调用 java.lang.Class 类中的 forName() 方法时,需要将要实例化的类的全称(比如 com.mxl.package.Student)作为参数传递过去,然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。

    3. 调用对象的 clone() 方法
    该方法不常用,使用该方法创建对象时,要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下:
    类名对象名=(类名)已创建好的类对象名.clone();

    4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法

    下面创建一个示例演示常用的前三种对象创建方法。示例代码如下:

    public class Student implements Cloneable
    {   
        //实现 Cloneable 接口
        private String Name;    //学生名字
        private int age;    //学生年龄
        public Student(String name,int age)
        {    //构造方法
            this.Name=name;
            this.age=age;
        }
        public Student()
        {
            this.Name="name";
            this.age=0;
        }
        public String toString()
        {
            return"学生名字:"+Name+",年龄:"+age;
        }
        public static void main(String[] args)throws Exception
        {
            System.out.println("---------使用 new 关键字创建对象---------");
           
            //使用new关键字创建对象
            Student student1=new Student("小刘",22);
            System.out.println(student1);
            System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
           
            //调用 java.lang.Class 的 newInstance() 方法创建对象
            Class cl=Class.forName("Student");
            Student student2=(Student)cl.newInstance();
            System.out.println(student2);
            System.out.println("-------------------调用对象的 clone() 方法创建对象----------");
            //调用对象的 clone() 方法创建对象
            Student student3=(Student)student2.clone();
            System.out.println(student3);
        }
    }
    
    

    对上述示例的说明如下:

    使用 new 关键字或 Class 对象的 newInstance() 方法创建对象时,都会调用类的掏造方法。
    使用 Class 类的 newInstance() 方法创建对象时,会调用类的默认构造方法,即无参构造方法。
    使用 Object 类的 clone() 方法创建对象时,不会调用类的构造方法,它会创建一个复制的对象,这个对象和原来的对象具有不同的内存地址,但它们的属性值相同。
    如果类没有实现 Cloneable 接口,则 clone。方法会抛出 java.lang.CloneNotSupportedException 异常,所以应该让类实现 Cloneable 接口。

    程序执行结果如下:

    ---------使用 new 关键字创建对象---------
    学生名字:小刘,年龄:22
    -----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------
    学生名字:name,年龄:0
    -------------------调用对象的done()方法创建对象----------
    学生名字:name,年龄:0
    

    隐含创建对象

    除了显式创建对象以外,在 Java 程序中还可以隐含地创建对象,例如下面几种情况。
    ①String strName=“strValue”,其中的“strValue”就是一个 String 对象,由 Java 虚拟机隐含地创建。
    ②字符串的“+”运算符运算的结果为一个新的 String 对象,示例如下:
    String str1=“Hello”;
    String str2=“Java”;
    String str3=str1+str2; //str3引用一个新的String对象
    ③当 Java 虚拟机加载一个类时,会隐含地创建描述这个类的 Class 实例。

    **提示:**类的加载是指把类的 .class 文件中的二进制数据读入内存中,把它存放在运行时数据区的方法区内,然后在堆区创建一个 java.lang.Class 对象,用来封装类在方法区内的数据结构。

    无论釆用哪种方式创建对象Java 虚拟机在创建一个对象时都包含以下步骤:

    1. 给对象分配内存。
    2. 将对象的实例变量自动初始化为其变量类型的默认值。
    3. 初始化对象,给实例变量赋予正确的初始值。

    注意: 每个对象都是相互独立的,在内存中占有独立的内存地址,并且每个对象都具有自己的生命周期,当一个对象的生命周期结束时,对象就变成了垃圾,由 Java 虚拟机自带的垃圾回收机制处理。

    展开全文
  • JDK1.8 创建线程池有哪几种方式?

    万次阅读 多人点赞 2019-05-16 12:48:53
    JDK1.8创建线程池有哪几种方式? newFixedThreadPool 定长线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程数量不再变化,当线程发生错误结束时,线程池会补充一个新的线程 测试代码...

    JDK1.8 创建线程池有哪几种方式?

    • newFixedThreadPool

    定长线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程数量不再变化,当线程发生错误结束时,线程池会补充一个新的线程

    测试代码:

    public class TestThreadPool {
    
    	//定长线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程数量不再变化,当线程发生错误结束时,线程池会补充一个新的线程
    	static ExecutorService fixedExecutor = Executors.newFixedThreadPool(3);
    	
    	
    	public static void main(String[] args) {
    		testFixedExecutor();
    	}
    	
    	//测试定长线程池,线程池的容量为3,提交6个任务,根据打印结果可以看出先执行前3个任务,3个任务结束后再执行后面的任务
    	private static void testFixedExecutor() {
    		for (int i = 0; i < 6; i++) {
    			final int index = i;
    			fixedExecutor.execute(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(3000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			});
    		}
    		
    		try {
    			Thread.sleep(4000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    		fixedExecutor.shutdown();
    	}
    	
    }

    打印结果:

    pool-1-thread-1 index:0
    pool-1-thread-2 index:1
    pool-1-thread-3 index:2
    4秒后...
    pool-1-thread-3 index:5
    pool-1-thread-1 index:3
    pool-1-thread-2 index:4

     

     

    • newCachedThreadPool

    可缓存的线程池,如果线程池的容量超过了任务数,自动回收空闲线程,任务增加时可以自动添加新线程,线程池的容量不限制

    测试代码:  

    public class TestThreadPool {
    
    	//可缓存的线程池,如果线程池的容量超过了任务数,自动回收空闲线程,任务增加时可以自动添加新线程,线程池的容量不限制
    	static ExecutorService cachedExecutor = Executors.newCachedThreadPool();
    	
    	
    	public static void main(String[] args) {
    		testCachedExecutor();
    	}
    	
    	//测试可缓存线程池
    	private static void testCachedExecutor() {
    		for (int i = 0; i < 6; i++) {
    			final int index = i;
    			cachedExecutor.execute(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(3000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			});
    		}
    		
    		try {
    			Thread.sleep(4000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    		cachedExecutor.shutdown();
    	}
    	
    }
    

    打印结果:

    pool-1-thread-1 index:0
    pool-1-thread-6 index:5
    pool-1-thread-5 index:4
    pool-1-thread-4 index:3
    pool-1-thread-3 index:2
    pool-1-thread-2 index:1
    4秒后...
    

     

     

    • newScheduledThreadPool

    定长线程池,可执行周期性的任务

    测试代码:

    public class TestThreadPool {
    
    	//定长线程池,可执行周期性的任务
    	static ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(3);
    	
    	
    	public static void main(String[] args) {
    		testScheduledExecutor();
    	}
    	
    	//测试定长、可周期执行的线程池
    	private static void testScheduledExecutor() {
    		for (int i = 0; i < 3; i++) {
    			final int index = i;
    			//scheduleWithFixedDelay 固定的延迟时间执行任务; scheduleAtFixedRate 固定的频率执行任务
    			scheduledExecutor.scheduleWithFixedDelay(new Runnable() {
    				public void run() {
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			}, 0, 3, TimeUnit.SECONDS);
    		}
    		
    		try {
    			Thread.sleep(4000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    		scheduledExecutor.shutdown();
    	}
    	
    }

    打印结果:

    pool-1-thread-1 index:0
    pool-1-thread-2 index:1
    pool-1-thread-3 index:2
    pool-1-thread-1 index:0
    pool-1-thread-3 index:1
    pool-1-thread-1 index:2
    4秒后...
    

     

     

    • newSingleThreadExecutor

    单线程的线程池,线程异常结束,会创建一个新的线程,能确保任务按提交顺序执行

    测试代码:

    public class TestThreadPool {
    	
    	//单线程的线程池,线程异常结束,会创建一个新的线程,能确保任务按提交顺序执行
    	static ExecutorService singleExecutor = Executors.newSingleThreadExecutor();
    	
    	
    	public static void main(String[] args) {
    		testSingleExecutor();
    	}
    	
    	//测试单线程的线程池
    	private static void testSingleExecutor() {
    		for (int i = 0; i < 3; i++) {
    			final int index = i;
    			singleExecutor.execute(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(3000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			});
    		}
    		
    		try {
    			Thread.sleep(4000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    		singleExecutor.shutdown();
    	}
    	
    }
    

    打印结果:

    pool-1-thread-1 index:0
    4秒后...
    pool-1-thread-1 index:1
    pool-1-thread-1 index:2

     

     

    • newSingleThreadScheduledExecutor

    单线程可执行周期性任务的线程池

    测试代码:

    public class TestThreadPool {
    	
    	//单线程可执行周期性任务的线程池
    	static ScheduledExecutorService singleScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
    	
    	
    	public static void main(String[] args) {
    		testSingleScheduledExecutor();
    	}
    	
    	//测试单线程可周期执行的线程池
    	private static void testSingleScheduledExecutor() {
    		for (int i = 0; i < 3; i++) {
    			final int index = i;
    			//scheduleWithFixedDelay 固定的延迟时间执行任务; scheduleAtFixedRate 固定的频率执行任务
    			singleScheduledExecutor.scheduleAtFixedRate(new Runnable() {
    				public void run() {
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			}, 0, 3, TimeUnit.SECONDS);
    		}
    		
    		try {
    			Thread.sleep(4000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    		singleScheduledExecutor.shutdown();
    	}
    	
    }

    打印结果:

    pool-1-thread-1 index:0
    pool-1-thread-1 index:1
    pool-1-thread-1 index:2
    pool-1-thread-1 index:0
    pool-1-thread-1 index:1
    pool-1-thread-1 index:2
    4秒后...
    

     

     

    • newWorkStealingPool

    任务窃取线程池,不保证执行顺序,适合任务耗时差异较大。

    线程池中有多个线程队列,有的线程队列中有大量的比较耗时的任务堆积,而有的线程队列却是空的,就存在有的线程处于饥饿状态,当一个线程处于饥饿状态时,它就会去其它的线程队列中窃取任务。解决饥饿导致的效率问题。

    默认创建的并行 level 是 CPU 的核数。主线程结束,即使线程池有任务也会立即停止。

    测试代码:

    public class TestThreadPool {
    
    	//任务窃取线程池
    	static ExecutorService workStealingExecutor = Executors.newWorkStealingPool();
    	
    	public static void main(String[] args) {
    		testWorkStealingExecutor();
    	}
    	
    	//测试任务窃取线程池
    	private static void testWorkStealingExecutor() {
    		for (int i = 0; i < 10; i++) {//本机 CPU 8核,这里创建10个任务进行测试
    			final int index = i;
    			workStealingExecutor.execute(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(3000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + " index:" + index);
    				}
    			});
    		}
    		
    		try {
    			Thread.sleep(4000);//这里主线程不休眠,不会有打印输出
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("4秒后...");
    		
    //		workStealingExecutor.shutdown();
    	}
    	
    }

    打印结果如下,index:8,index:9并未打印出:

    ForkJoinPool-1-worker-1 index:0
    ForkJoinPool-1-worker-7 index:6
    ForkJoinPool-1-worker-5 index:4
    ForkJoinPool-1-worker-3 index:2
    ForkJoinPool-1-worker-4 index:3
    ForkJoinPool-1-worker-2 index:1
    ForkJoinPool-1-worker-0 index:7
    ForkJoinPool-1-worker-6 index:5
    4秒后...
    

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 创建线程池有哪几种方式

    千次阅读 2020-05-04 22:15:27
    创建线程池有哪几种方式一、Executors二、ThreadPoolExecutor 一、Executors Executors是一个线程相关的工具类。主要提供了以下几种创建线程池的方法: index method corePoolSize maximumPoolSize ...

    一、Executors

    Executors是一个线程相关的工具类。主要提供了以下几种创建线程池的方法:

    indexmethodcorePoolSizemaximumPoolSizekeepAliveTimeunitworkQueue
    1newCachedThreadPool0Integer.MAX_VALUE60LTimeUnit.SECONDSSynchronousQueue
    2newFixedThreadPool自定义与corePoolSize相同0LTimeUnit.MILLISECONDSLinkedBlockingQueue
    3newSingleThreadExecutor110LTimeUnit.MILLISECONDSLinkedBlockingQueue
    4newScheduledThreadPool自定义Integer.MAX_VALUE0NANOSECONDSDelayedWorkQueue
    5newSingleThreadScheduledExecutor1Integer.MAX_VALUE0NANOSECONDSDelayedWorkQueue

    第1,4,5种:线程最大数量是Integer.MAX_VALUE,当执行大量耗时任务时,容易造成堆外内存溢出
    第2,3种:使用的的阻塞队列为无边界队列,当任务量过大时,可能会导致内存溢出

    注意: 在java8中新添加了newWorkStealingPool

    二、ThreadPoolExecutor

    ThreadPoolExecutor(int corePoolSize, //核心线程数量
                       int maximumPoolSize, // 最大线程数量
                       long keepAliveTime, // 存活时间 
                       TimeUnit unit, // 时间单位
                       BlockingQueue<Runnable> workQueue, //阻塞队列
                       ThreadFactory threadFactory) // 拒绝策略
    

    注意: 有多于corePoolSize但小于maximumPoolSize线程正在运行,则仅当队列已满时才会创建新线程

    在这里插入图片描述

    展开全文
  • 创建线程有哪几种方式?3种

    千次阅读 2020-07-20 08:17:10
    1.继承Thread类型重写run 方法 public class ThreadDemoTest extends Thread{ @Override public void run() { System.out.println("通过继承Thread类重写run方法实现接口!"); } public static void main...

    1.继承Thread类型重写run 方法

    public class ThreadDemoTest extends Thread{
        @Override
        public void run() {
            System.out.println("通过继承Thread类重写run方法实现接口!");
        }
     
        public static void main(String[] args) {
            ThreadDemoTest threadDemoTest = new ThreadDemoTest();
            threadDemoTest.run();
        }
    }
    

    2.实现Runnable接口

    public class RunnableDemoTest implements Runnable{
     
        public void run() {
            System.out.println("实现Runnable开启线程!");
        }
     
        public static void main(String[] args) {
            Thread thread = new Thread(new RunnableDemoTest());
            thread.start();
        }
    }
    

    3.实现Callable接口

    public class CallableDemoTest implements Callable {
        public Object call() {
            return "HelloCallable!";
        }
     
        @Test
        public void test() throws ExecutionException, InterruptedException {
            CallableDemoTest callableDemoTest = new CallableDemoTest();
            FutureTask futureTask = new FutureTask(callableDemoTest);
            Thread thread = new Thread(futureTask);
            thread.start();
            //获取返回值
            futureTask.get();
        }
    }
    
    展开全文
  • RDD的几种创建方式

    万次阅读 2017-09-10 17:21:47
    Spark中RDD的几种创建方式,及在Spark核心编程过程中值得注意的几点
  • Java创建类的实例的几种方法

    万次阅读 2017-07-06 14:56:40
    Java创建类的实例的几种方法
  • js创建对象的几种方式-转载

    千次阅读 2018-05-22 10:18:17
     2、构造函数模式 与工厂模式相比: 1、没有显式的创建对象 2、直接将属性和方法赋给了this对象 3、没有return语句 要创建person的实例,必须使用new操作符,以这种方式调用构造函数实际上会经历4个步骤: 1...
  • 1. 直接创建空字典 dic = {} print(type(dic)) # 输出结果:<class 'dict'> 2. 直接赋值创建字典 dic = {'name': 'Jack', 'age': 18, 'height': 180} print(dic) # 输出结果:{'name': 'Jack', 'age': 18, '...
  • JavaScript 创建对象的几种方式

    千次阅读 2018-07-13 09:43:41
    这里创建对象,主要介绍三方式:工厂模式、构造函数模式、原型模式、组合使用构造函数模式和原型模式。1、工厂模式 工厂模式是用函数来封装创建对象的细节,在函数里面创建对象并返回对象。function createPerson...
  • java创建对象的几种方式

    千次阅读 2018-09-17 16:57:17
    1、通过java关键字NEW创建对象 最简单最常用的创建对象方式,包括无参的和有参的构造函数。 例如: 通过NEW关键字创建方式: Test test = new Test();//通过无参构造函数创建 Test test1 = new Test(this);//...
  • Spring:创建Bean的几种方式

    万次阅读 多人点赞 2016-06-04 17:42:21
    Spring创建工厂的三方式
  • 数据库创建索引的几种方法

    万次阅读 多人点赞 2018-11-09 10:46:26
    1、普通索引  CREATE INDEX indexName ON mytable(username(length)... 创建表的时候直接指定:  CREATE TABLE mytable(  ID INT NOT NULL,   username VARCHAR(16) NOT NULL,   INDEX [indexName] (...
  • Spring创建对象的几种方式

    千次阅读 2018-03-26 11:04:59
    Spring的核心思想是IOC,即所有对象的创建都是...Spring创建对象有以下几种方式: 无参构造器 有参构造器 工厂模式 静态方法 非静态方法 构造器创建对象 applicationContext.xml &lt;beans xmlns="...
  • 创建dblink的几种方法

    万次阅读 2018-12-15 00:55:59
    结合平日的经验,现总结几种创建dblink的方法: (1) 最常用的方法: create database link dblink_120 connect to zhan identified by “zhan” using '(DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)...
  • java中创建对象的几种方式

    千次阅读 2017-06-26 15:58:42
    创建对象的几种方式
  • java创建线程的三方式: 继承Thread类创建线程类 通过Runable接口创建线程类 通过Callable和FutureTask创建线程 总结下: 实现Runnable和实现Callable接口的方式基本相同,不过是后者执行call()方法有返回值。 1...
  • 创建vue项目的几种方式

    千次阅读 2020-04-08 17:51:08
    最近一段时间在学习vuejs和element-ui、iview-ui这些前端知识,在创建vuejs项目时发现有几种不同的方法: 使用vue-cli脚手架创建新vuejs项目 用vue-cli脚手架可以快速的构建出一个前端vue框架的项目结构 前提条件:...
  • JS创建函数的几种方式

    千次阅读 2018-11-22 10:40:06
    js中创建函数的三方式: 第一(函数声明):  function sum1(num1,num2){  return num1+num2; } sum1(10,20); 第二(函数表达式): var sum2 = function(num1,num2){  return num1+num2; } sum(10,20)...
  • 创建字典的几种方式(全)

    千次阅读 2020-08-04 10:04:55
    1,创建空字典 dic = {} type (dic) #output:<type 'dict'> 2,直接赋值创建字典 dic = {'aaa':1, 'bbb':2, 'ccc':3} 3,通过dict将二元组列表创建为字典 list = [('aaa', 1), ('bbb', 2), ('ccc', 3...
  • JavaScript创建对象的4种方法

    千次阅读 2018-11-28 15:02:24
    JavaScript 创建对象的4种方法 所谓对象就是用来帮助你完成一些事情是,对象是有特征和行为的,是具体特指的某一个事物。使用对象可以使程序更加整洁 通过Object()方法来创建 Object()是JavaScript内部的对象...
  • 下面IT技术资料分享网小编就给大家整理了几种创建Windows快捷方式的几种方法:1. 在电脑桌面(或者资源管理器中)对着空白的地方点击右键,在菜单中找到新建-桌面快捷方式,根据提示进行创建一个快捷方式就可以了。2...
  • java几种创建字符串的方法

    千次阅读 2018-09-19 09:02:17
    JAVA有几种创建字符串的方法1)通过引用字符数组来创建字符串 char a[]={'A','b','c','E'}; String str1=new String(a); System.out.println(str1); 2)先定义后赋值 String str2; str2="this is a book";...
  • java中实现多线程的方法哪几种

    千次阅读 2018-09-21 23:55:25
    实现多线程的方法有三: 实现Runnable接口,并实现接口的run()方法 继承Thread类,重写run方法 实现Callable接口,重写call()方法 实现Runnable接口,并实现接口的run()方法 (1)自定义类并实现Runnable接口,...
  • Python中创建字典的几种方法

    万次阅读 多人点赞 2016-04-03 21:27:37
    1.传统的文字表达式:>>> d={'name':'Allen','age':21,'gender':'male'} >>> d {'age': 21, 'name': 'Allen', 'gender': 'male'}如果你可以事先拼出整个字典,这种方式是很方便的。2.动态分配键值:>>> d={} ...
  • javascript中创建对象的几种方式

    万次阅读 2012-08-27 22:24:33
    javascript 中常见的创建对象的几种方式。    1. 简单对象的创建 使用对象字面量的方式{} 创建一个对象(最简单,好理解,推荐使用) var Cat = {};//JSON Cat.name="kity";//添加属性并赋值 Cat.age=2; Cat....
  • android 创建多线程的几种方法

    万次阅读 2014-06-16 23:48:45
    相比而言,种方法更好呢?   在Java中,类仅支持单继承,也就是说,当定义一个新的类的时候,它只能扩展一个外部类.这样,如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的,那么这个自定义...
  • java8 Stream-创建流的几种方式

    万次阅读 多人点赞 2018-06-09 17:00:13
    前面(《java8 Stream接口简介》),我们已经对stream这个接口,做了简单的介绍,下面,我们用几个案例,来看看流的几种创建方式 String[] dd = { "a", "b", "c" }; Arrays.stream(dd).forEach(System.out::...
  • 创建字典的几种简单的方式

    千次阅读 2019-03-20 16:29:59
    Python创建dict的几种方法 声明:转自CSDN (http://blog.csdn.net/csujiangyu/article/details/45176399) 1. 创建空字典 >>> dic = {} >>> type(dic) <type 'dict'> 2.直接赋值创建 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,617,847
精华内容 647,138
关键字:

创建那哪几种方法