MongoDB之Java测试代码（DAO层）-MySQL 튜토리얼-php.cn

집

데이터 베이스

MySQL 튜토리얼

MongoDB之Java测试代码（DAO层）

WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB

Jun 07, 2016 pm 04:06 PM

dao java mongodb 암호 시험

MongoInit.java是数据库初始化及连接类 MongoUtils.java是对mongodb的各种操作方法 MongoInit.java package com.wlwcloud.datatest;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.net.UnknownHostException;i

MongoInit.java是数据库初始化及连接类

MongoUtils.java是对mongodb的各种操作方法

MongoInit.java

package com.wlwcloud.datatest;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.UnknownHostException;
import java.util.Properties;

import org.apache.log4j.Logger;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.mongodb.MongoOptions;
import com.mongodb.ServerAddress;

/**
 * Mongo工具类:设计为单例模式，每当月份发生变化，数据库连接名称就会发生变化，这是业务规则 因MongoDB的Java驱动是线程安全的，对于一般的应用，只要一个Mongo实例即可，Mongo有个内置的连接池（池大小默认为10个）。
 * 对于有大量写和读的环境中，为了确保在一个Session中使用同一个DB时，我们可以用以下方式保证一致性： DB mdb =mongo.getDB(&#39;dbname&#39;); mdb.requestStart(); // 业务代码 mdb.requestDone();
 * DB和DBCollection是绝对线程安全的
 * @author undoner
 */
public class MongoInit {
	/** DB监听端口号 */
	private static int DBPort = 27017;
	/** DB连接URL */
	private static String DBUrl = "localhost";
	/** 连接DB库名称 */
	private static String DBName = "wlwdb";
	static Logger log = Logger.getRootLogger();
	private static Mongo mongo;
	private static DBCollection coll;
	private static DB db;

	static {
		try {
			DBproperties();
			MongoOptions options = new MongoOptions();
			options.autoConnectRetry = true;
			options.connectionsPerHost = 1000;
			options.maxWaitTime = 5000;
			options.socketTimeout = 0;
			options.connectTimeout = 15000;
			options.threadsAllowedToBlockForConnectionMultiplier = 5000;
			// 事实上，Mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个Mongo实例对我们来说已经足够了
			ServerAddress serverAddress = new ServerAddress(DBUrl, DBPort);
			mongo = new Mongo(serverAddress, options);
		} catch (UnknownHostException e) {
			log.info("get mongo instance failed");
		}
	}

	static void DBproperties() {
		// 读取配置文件config.properties中的属性值
		String myFilePath = MongoInit.class.getResource("/").getPath() + "MongoDBConfig.properties";
		Properties properties = new Properties();
		FileInputStream fileInputStream = null;
		try {
			   fileInputStream = new FileInputStream(myFilePath);
			   properties.load(fileInputStream);
			   DBPort = Integer.parseInt((String) properties.getProperty("DBPort"));
			   DBUrl = (String) properties.getProperty("DBUrl");
			   DBName = (String) properties.getProperty("DBName");
			  } catch (Exception e) {
			   e.printStackTrace();
			  } finally {
			   try {
			    fileInputStream.close();
			   } catch (IOException e) {
			    // TODO Auto-generated catch block
			    e.printStackTrace();
			   }
		}

	}

	public static DB getDB() {
		if (db == null) {
			db = mongo.getDB(DBName);
		}
		return db;
	}

	public static Mongo getMong() {
		return mongo;
	}

	public static DBCollection getColl(String collname) {
		return getDB().getCollection(collname);
	}

}

로그인 후 복사

package com.wlwcloud.datatest;

import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ketayao.ketacustom.entity.main.User;
import com.ketayao.utils.SecurityUtils;
import com.mongodb.AggregationOutput;
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MapReduceCommand;
import com.mongodb.MapReduceOutput;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.QueryBuilder;
import com.mongodb.WriteConcern;

public class MongoUtils {
	//DBCursor cursor = coll.find(condition).addOption(Bytes.QUERYOPTION_NOTIMEOUT);//设置游标不要超时  
     
    /** 
     * 获取所有数据库实例 
     */  
    public void testGetDBS() {  
        List<String> dbnames = MongoInit.getMong().getDatabaseNames();  
        for (String dbname : dbnames) {  
            System.out.println("dbname:" + dbname);  
        }  
    }  
  
     
    /** 
     * 删除数据库 
     */  
    public void dropDatabase(String dbname) {  
        MongoInit.getMong().dropDatabase(dbname);  
    }  
  
     
    /** 
     * 查询所有表名 
     */  
    public void getAllCollections() {  
        Set<String> colls = MongoInit.getDB().getCollectionNames();  
        for (String s : colls) {  
            System.out.println("Collections:"+s);  
        }  
    }  
  
    /** 
     * 删除一个表 
     */  
    public void dropCollection(String collection) {  
        MongoInit.getColl(collection).drop();  
    }  
  
    /** 
     * 添加一条记录 
     */  
     
    public void addData(String dbCollection,String dataID,String dataTime,String dataContent,String dataStatus) {  
        DBCollection coll = MongoInit.getColl(dbCollection);  
        BasicDBObject doc = new BasicDBObject();  
        doc.put("id", dataID);  
        doc.put("time", dataTime);  
        doc.put("data", dataContent);  
        doc.put("status", dataStatus);  
        coll.insert(doc);  
        // 设定write concern，以便操作失败时得到提示  
        coll.setWriteConcern(WriteConcern.SAFE);  
        findOne(dbCollection);
    }  
  
     
    /** 
     * 创建索引 
     */  
    public void createIndex(String collection) {  
        MongoInit.getColl(collection).createIndex(new BasicDBObject("index_id", 1));  
    }  
  
     
    /** 
     * 获取索引信息 
     */  
    public void getIndexInfo(String dbCollection) {  
        List<DBObject> list = MongoInit.getColl(dbCollection).getIndexInfo();  
        for (DBObject o : list) {  
            System.out.println(o);  
        }  
    }  
  
     
    /** 
     * 添加多条记录 
     */  
    public void addMultiData() {  
        for (int i = 0; i < 100; i++) {  
            MongoInit.getColl("wujintao").insert(  
                    new BasicDBObject().append("i", i));  
        }  
  
        List<DBObject> docs = new ArrayList<DBObject>();  
        for (int i = 0; i < 50; i++) {  
            docs.add(new BasicDBObject().append("i", i));  
        }  
        MongoInit.getColl("wujintao").insert(docs);  
        // 设定write concern，以便操作失败时得到提示  
        MongoInit.getColl("wujintao").setWriteConcern(WriteConcern.SAFE);  
    }  
  
     
    /** 
     * 查找第一条记录 
     */  
    public void findOne(String dbCollection) {  
        DBObject myDoc = MongoInit.getColl(dbCollection).findOne();  
        System.out.println(myDoc);  
    }  
  
     
    /** 
     * 获取表中所有记录条数 
     */  
    public void count(String dbCollection) {  
        System.out.println(MongoInit.getColl(dbCollection).getCount());  
        System.out.println(MongoInit.getColl(dbCollection).count());  
    }  
  
     
    /** 
     * 获取查询结果集的记录数 
     */  
    public void getCount(String dbCollection,String dataID) {  
        DBObject query = new BasicDBObject("id", dataID);  
        long count = MongoInit.getColl(dbCollection).count(query);  
        System.out.println(count);  
    }  
  
     
    /** 
     * 查询所有结果 
     */  
    public void getAllDocuments(String dbCollection) {  
        DBCursor cursor = MongoInit.getColl(dbCollection).find();  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
  
     
    /** 
     * 按照一个条件查询 
     */  
    public void queryByConditionOne() {  
        BasicDBObject query = new BasicDBObject();  
        query.put("name", "MongoDB");  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query);  
  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
    public List<SensorData> queryById(String id) { 
    	User user = SecurityUtils.getLoginUser();
        BasicDBObject query = new BasicDBObject();  
        System.out.print(id);
        query.put("id", id);  
        String table="table_";
        DBCursor cursor = MongoInit.getColl("table_"+user.getUsername()).find(query);  
        List<DBObject> list=cursor.toArray();
        System.out.println(list.size());
        System.out.println("dao.."+list.toString());
        List<SensorData> sensordata=new ArrayList<SensorData>();
        for(int i=1;i<list.size();i++)
        {
        	String sid=(String)list.get(i).get("id");
        	String stime=(String)list.get(i).get("time");
        	String sdata=(String)list.get(i).get("data");
        	String status=(String)list.get(i).get("status");
        	String sstatus;
        	if(status.equals("0"))sstatus="正常";
        	else if(status.equals("1")) sstatus="删除";
        	else sstatus="未知状态";
            SensorData a=new SensorData(sid,stime,sdata,sstatus);
        //System.out.print(a.getData()+a.getId()+a.getStatus()+a.getTime());
        sensordata.add(a);
        }
        return sensordata;
       /* try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        } */ 
    }  
     
    /** 
     * AND多条件查询,区间查询 
     */  
    public void queryMulti() {  
        BasicDBObject query = new BasicDBObject();  
        // 查询j不等于3,k大于10的结果集  
        query.put("j", new BasicDBObject("$ne", 3));  
        query.put("k", new BasicDBObject("$gt", 10));  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query);  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
  
     
    /** 
     * 区间查询 
     * select * from table where i >50 
     */  
    public void queryMulti2() {  
        BasicDBObject query = new BasicDBObject();  
        query = new BasicDBObject();  
        query.put("i", new BasicDBObject("$gt", 50)); // e.g. find all where i >  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query);  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
  
     
    /** 
     * 区间查询 
     * select * from table where 20 < i <= 30 
        //比较符    
        //"$gt"： 大于    
        //"$gte"：大于等于    
        //"$lt"： 小于    
        //"$lte"：小于等于    
        //"$in"： 包含    
     */  
    public void queryMulti3() {  
        BasicDBObject query = new BasicDBObject();  
        query = new BasicDBObject();  
  
        query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query);  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
  
    /** 
     * 组合in和and select * from test_Table where (a=5 or b=6) and (c=5 or d = 6) 
     */  
    public void queryMulti4() {  
        BasicDBObject query11 = new BasicDBObject();  
        query11.put("a", 1);  
        BasicDBObject query12 = new BasicDBObject();  
        query12.put("b", 2);  
        List<BasicDBObject> orQueryList1 = new ArrayList<BasicDBObject>();  
        orQueryList1.add(query11);  
        orQueryList1.add(query12);  
        BasicDBObject orQuery1 = new BasicDBObject("$or", orQueryList1);  
  
        BasicDBObject query21 = new BasicDBObject();  
        query21.put("c", 5);  
        BasicDBObject query22 = new BasicDBObject();  
        query22.put("d", 6);  
        List<BasicDBObject> orQueryList2 = new ArrayList<BasicDBObject>();  
        orQueryList2.add(query21);  
        orQueryList2.add(query22);  
        BasicDBObject orQuery2 = new BasicDBObject("$or", orQueryList2);  
  
        List<BasicDBObject> orQueryCombinationList = new ArrayList<BasicDBObject>();  
        orQueryCombinationList.add(orQuery1);  
        orQueryCombinationList.add(orQuery2);  
  
        BasicDBObject finalQuery = new BasicDBObject("$and",  
                orQueryCombinationList);  
        DBCursor cursor = MongoInit.getColl("wujintao").find(finalQuery);  
    }  
  
     
    /** 
     * IN查询 
     * if i need to query name in (a,b); just use { name : { $in : [&#39;a&#39;, &#39;b&#39;] } } 
     * select * from things where name=&#39;a&#39; or name=&#39;b&#39; 
     * @param coll 
     */  
    public void queryIn() {  
        BasicDBList values = new BasicDBList();  
        values.add("a");  
        values.add("b");  
        BasicDBObject in = new BasicDBObject("$in", values);  
        DBCursor cursor = MongoInit.getColl("wujintao").find(  
                new BasicDBObject("name", in));  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
  
     
    /** 
     * 或查询 
     * select * from table where name  = &#39;12&#39; or title = &#39;p&#39; 
     * @param coll 
     */  
    public void queryOr() {  
        QueryBuilder query = new QueryBuilder();  
        query.or(new BasicDBObject("name", 12), new BasicDBObject("title", "p"));  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query.get()).addSpecial("$returnKey", "");  
        try {  
            while (cursor.hasNext()) {  
                System.out.println(cursor.next());  
            }  
        } finally {  
            cursor.close();  
        }  
    }  
      
     
    public void customQueryField() throws UnknownHostException{  
        Mongo mongo = new Mongo("localhost", 27017);  
        DB db = mongo.getDB("zhongsou_ad");  
        BasicDBObjectBuilder bulder = new BasicDBObjectBuilder();  
        bulder.add("times",1);  
        bulder.add("aid",1);  
        DBCursor cusor =  db.getCollection("ad_union_ad_c_1").find(new BasicDBObject(),bulder.get());  
        for (DBObject dbObject : cusor) {  
            System.out.println(dbObject);  
        }  
    }  
      
     
    public void mapReduce() throws UnknownHostException{  
        Mongo mongo = new Mongo("localhost", 27017);  
        DB db = mongo.getDB("zhongsou_ad");  
        /*** 
         *  book1 = {name : "Understanding JAVA", pages : 100} 
         *  book2 = {name : "Understanding JSON", pages : 200} 
         *  db.books.save(book1) 
         *  db.books.save(book2) 
         *  book = {name : "Understanding XML", pages : 300} 
         *  db.books.save(book) 
         *  book = {name : "Understanding Web Services", pages : 400} 
         *  db.books.save(book) 
         *  book = {name : "Understanding Axis2", pages : 150} 
         *  db.books.save(book)   
         *   
        var map = function() { 
            var category; 
            if ( this.pages >= 250 ) 
                category = &#39;Big Books&#39;; 
            else 
                category = "Small Books"; 
            emit(category, {name: this.name}); 
        }; 
        var reduce = function(key, values) { 
            var sum = 0; 
            values.forEach(function(doc) { 
                sum += 1; 
            }); 
            return {books: sum}; 
        };        
        var count  = db.books.mapReduce(map, reduce, {out: "book_results"}); 
         */  
        try {  
  
            DBCollection books = db.getCollection("books");  
  
            BasicDBObject book = new BasicDBObject();  
            book.put("name", "Understanding JAVA");  
            book.put("pages", 100);  
            books.insert(book);  
              
            book = new BasicDBObject();    
            book.put("name", "Understanding JSON");  
            book.put("pages", 200);  
            books.insert(book);  
              
            book = new BasicDBObject();  
            book.put("name", "Understanding XML");  
            book.put("pages", 300);  
            books.insert(book);  
              
            book = new BasicDBObject();  
            book.put("name", "Understanding Web Services");  
            book.put("pages", 400);  
            books.insert(book);  
            
            book = new BasicDBObject();  
            book.put("name", "Understanding Axis2");  
            book.put("pages", 150);  
            books.insert(book);  
              
            String map = "function() { "+   
                      "var category; " +    
                      "if ( this.pages >= 250 ) "+    
                      "category = &#39;Big Books&#39;; " +  
                      "else " +  
                      "category = &#39;Small Books&#39;; "+    
                      "emit(category, {name: this.name});}";  
              
            String reduce = "function(key, values) { " +  
                                     "var sum = 0; " +  
                                     "values.forEach(function(doc) { " +  
                                     "sum += 1; "+  
                                     "}); " +  
                                     "return {books: sum};} ";  
              
            MapReduceCommand cmd = new MapReduceCommand(books, map, reduce,  
              null, MapReduceCommand.OutputType.INLINE, null);  
  
            MapReduceOutput out = books.mapReduce(cmd);  
  
            for (DBObject o : out.results()) {  
             System.out.println(o.toString());  
            }  
           } catch (Exception e) {  
             e.printStackTrace();  
           }  
    }  
      
     
    public void GroupByManyField() throws UnknownHostException{  
        //此方法没有运行成功  
        Mongo mongo = new Mongo("localhost", 27017);  
        DB db = mongo.getDB("libary");  
        DBCollection books = db.getCollection("books");  
        BasicDBObject groupKeys = new BasicDBObject();  
        groupKeys.put("total", new BasicDBObject("$sum","pages"));  
          
        BasicDBObject condition = new BasicDBObject();  
        condition.append("pages", new BasicDBObject().put("$gt", 0));  
     
          
        String reduce = "function(key, values) { " +  
                "var sum = 0; " +  
                "values.forEach(function(doc) { " +  
                "sum += 1; "+  
                "}); " +  
                "return {books: sum};} ";  
        /** 
         BasicDBList basicDBList = (BasicDBList)db.getCollection("mongodb中集合编码或者编码") 
                   .group(DBObject key,   --分组字段，即group by的字段 
                DBObject cond,        --查询中where条件 
                DBObject initial,     --初始化各字段的值 
                String reduce,        --每个分组都需要执行的Function 
                String finial         --终结Funciton对结果进行最终的处理 
         */  
        DBObject obj = books.group(groupKeys, condition,  new BasicDBObject(), reduce);  
        System.out.println(obj);  
          
        AggregationOutput ouput = books.aggregate(new BasicDBObject("$group",groupKeys));  
        System.out.println(ouput.getCommandResult());  
        System.out.println(books.find(new BasicDBObject("$group",groupKeys)));  
    }     
      
     
    /** 
     * 分页查询    
     */  
    public void pageQuery() {  
        DBCursor cursor = MongoInit.getColl("wujintao").find().skip(0)  
                .limit(10);  
        while (cursor.hasNext()) {  
            System.out.println(cursor.next());  
        }  
    }  
  
    /** 
     * 模糊查询 
     */  
    public void likeQuery() {  
        Pattern john = Pattern.compile("joh?n");  
        BasicDBObject query = new BasicDBObject("name", john);  
  
        // finds all people with "name" matching /joh?n/i  
        DBCursor cursor = MongoInit.getColl("wujintao").find(query);  
    }  
  
     
    /** 
     * 条件删除    
     */  
    public void delete(String dbCollection,String dataID) {  
        BasicDBObject query = new BasicDBObject();  
        query.put("id", dataID);  
        // 找到并且删除，并返回删除的对象  
        DBObject removeObj = MongoInit.getColl(dbCollection).findAndRemove(query);  
        System.out.println(removeObj);  
    }  
  
     
    /** 
     * 更新 
     */  
    public void update() {  
        BasicDBObject query = new BasicDBObject();  
        query.put("name", "liu");  
        DBObject stuFound = MongoInit.getColl("wujintao").findOne(query);  
        stuFound.put("name", stuFound.get("name") + "update_1");  
        MongoInit.getColl("wujintao").update(query, stuFound);  
    }  
	
    public void testGpsData() {  
    	try {
			//13862082455:117.13172:029.77659:131.2580
    		Date d = new Date(); 
			SimpleDateFormat  sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
			String dateNowStr = sdf.format(d);  
			System.out.println(dateNowStr);
			
    		DBCollection coll = MongoInit.getColl("table_admin");  
            BasicDBObject doc = new BasicDBObject();  
            doc.put("id", "12345678");  
            doc.put("time", dateNowStr);  
            doc.put("data", "117.13172:029.77659:131.2580");  
            doc.put("status", "0");
            coll.insert(doc);  
            // 设定write concern，以便操作失败时得到提示  
            coll.setWriteConcern(WriteConcern.SAFE);  

			BasicDBObject dsort = new BasicDBObject();
			dsort.put("time", -1);
			
			BasicDBObject searchDevice = new BasicDBObject();
			searchDevice.put("id", "12345678");
			DBCursor cursor = coll.find(searchDevice).sort(dsort);		
			
			List<DBObject> list = cursor.toArray();
			//ArrayList<SensorData> listSensorData=new ArrayList<SensorData>(list.size());
			
			ObjectMapper mapper = new ObjectMapper();  
			String jsonfromList = null;
			try {
				//list转json
				jsonfromList = mapper.writeValueAsString(list);
			} catch (JsonProcessingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}  
	        //System.out.println(jsonfromList);  
//			for(int i=0;i<list.size();i++)
//			{
//				System.out.println((String) list.get(i).get("time"));
			//}
			
			//System.out.println(list.size()+","+listSensorData);//list的长度
//		    System.out.println(cursor.count());//计算结果的数量，类似于(mysql count()函数),不受limit的影响
			
//			while (cursor.hasNext()) {
//				System.out.println(cursor.next());
//			}
			System.out.println("The Search Query has Executed!");
		} catch (MongoException e) {
			e.printStackTrace();
		}
    }  
    
    public static void main(String[] args) {
    	String dbname="wlwdb";
    	String dbCollection="table_admin";
    	String dbCollection1="15257102317";
    	String dataID="12345678";
		MongoUtils tb=new MongoUtils();
		tb.testGetDBS();//查询所有数据库
		tb.getAllCollections();//查询所有表
//		
//		tb.findOne(dbCollection);//查找第一条记录
		tb.testGpsData();
		tb.getAllDocuments(dbCollection);//获取制定表明的所有数据
		//tb.dropDatabase(dbname);//删除指定数据库
		//tb.delete(dbCollection,dataID);//删除制定表明和设备ID的数据
		//tb.dropCollection(dbCollection);// 删除一个表
		
		//tb.createIndex(dbCollection1);//创建索引
		//tb.getIndexInfo(dbCollection1);//获得表中所有索引
	}
}

로그인 후 복사

#端口设置
DBPort=27017
#URL
DBUrl=localhost
#URL
DBName=wlwdb

로그인 후 복사

본 웹사이트의 성명

본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.

핫 AI 도구

Undresser.AI Undress

사실적인 누드 사진을 만들기 위한 AI 기반 앱

AI Clothes Remover

사진에서 옷을 제거하는 온라인 AI 도구입니다.

Undress AI Tool

무료로 이미지를 벗다

Clothoff.io

AI 옷 제거제

AI Hentai Generator

AI Hentai를 무료로 생성하십시오.

뜨거운 도구

메모장++7.3.1

사용하기 쉬운 무료 코드 편집기

SublimeText3 중국어 버전

중국어 버전, 사용하기 매우 쉽습니다.

스튜디오 13.0.1 보내기

강력한 PHP 통합 개발 환경

드림위버 CS6

시각적 웹 개발 도구

SublimeText3 Mac 버전

신 수준의 코드 편집 소프트웨어(SublimeText3)

뜨거운 주제

Gmail 이메일의 로그인 입구는 어디에 있나요?

7364

자바 튜토리얼

1628

Cakephp 튜토리얼

1353

라라벨 튜토리얼

1265

PHP 튜토리얼

1214

Related knowledge

자바의 제곱근 Aug 30, 2024 pm 04:26 PM

자바의 제곱근 안내 여기서는 예제와 코드 구현을 통해 Java에서 Square Root가 어떻게 작동하는지 설명합니다.

자바의 완전수 Aug 30, 2024 pm 04:28 PM

Java의 완전수 가이드. 여기서는 정의, Java에서 완전 숫자를 확인하는 방법, 코드 구현 예제에 대해 논의합니다.

Java의 난수 생성기 Aug 30, 2024 pm 04:27 PM

Java의 난수 생성기 안내. 여기서는 예제를 통해 Java의 함수와 예제를 통해 두 가지 다른 생성기에 대해 설명합니다.

자바의 웨카 Aug 30, 2024 pm 04:28 PM

Java의 Weka 가이드. 여기에서는 소개, weka java 사용 방법, 플랫폼 유형 및 장점을 예제와 함께 설명합니다.

자바의 암스트롱 번호 Aug 30, 2024 pm 04:26 PM

자바의 암스트롱 번호 안내 여기에서는 일부 코드와 함께 Java의 Armstrong 번호에 대한 소개를 논의합니다.

Java의 스미스 번호 Aug 30, 2024 pm 04:28 PM

Java의 Smith Number 가이드. 여기서는 정의, Java에서 스미스 번호를 확인하는 방법에 대해 논의합니다. 코드 구현의 예.

Java Spring 인터뷰 질문 Aug 30, 2024 pm 04:29 PM

이 기사에서는 가장 많이 묻는 Java Spring 면접 질문과 자세한 답변을 보관했습니다. 그래야 면접에 합격할 수 있습니다.

Java 8 Stream foreach에서 나누거나 돌아 오시겠습니까? Feb 07, 2025 pm 12:09 PM

Java 8은 스트림 API를 소개하여 데이터 컬렉션을 처리하는 강력하고 표현적인 방법을 제공합니다. 그러나 스트림을 사용할 때 일반적인 질문은 다음과 같은 것입니다. 기존 루프는 조기 중단 또는 반환을 허용하지만 스트림의 Foreach 메소드는이 방법을 직접 지원하지 않습니다. 이 기사는 이유를 설명하고 스트림 처리 시스템에서 조기 종료를 구현하기위한 대체 방법을 탐색합니다. 추가 읽기 : Java Stream API 개선 스트림 foreach를 이해하십시오 Foreach 메소드는 스트림의 각 요소에서 하나의 작업을 수행하는 터미널 작동입니다. 디자인 의도입니다

See all articles

MongoDB之Java测试代码（DAO层）

핫 AI 도구

Undresser.AI Undress

AI Clothes Remover

Undress AI Tool

Clothoff.io

AI Hentai Generator

인기 기사

뜨거운 도구

메모장++7.3.1

SublimeText3 중국어 버전

스튜디오 13.0.1 보내기

드림위버 CS6

SublimeText3 Mac 버전

뜨거운 주제