精华内容
下载资源
问答
  • redis的列表类型list是一个常用的数据类型,但是这个类型并不支持一次返回个值并删除这些已经返回的值。

    redis的列表类型list是一个常用的数据类型,但是这个类型并不支持一次性返回多个值并删除这些已经返回的值。


    其实我们可以通过redis的事务,来完成这个一次性返回多个值并删除这些已经返回的值的需求。

    redis中的事务就是一组命令的集合,这些命令要么全部执行,要么全都不执行。redis事务的原理就是一次性将命令都发给服务端,

    当服务接收到exec命令之后,按照事务中命令的顺序依次执行事务中的命令。exec命令的返回值就是事务中依次执行的命令返回值的集合,返回值的顺序和命令的执行顺序相同。如果在发送exec命令前,客户端和服务端失去连接,这时redis会清空这个事务队列。

    介绍完这些原理,我们再来看看如何完成一次性返回多个值并删除这些已经返回的值的需求。


    我们这里要利用两个列表类型的命令:lrange和ltrim

    lrange key start end // 从左边依次返回key的[start,end] 的所有值,注意返回结果包含两端的值。

    ltrim  key  start end //删除指定索引之外的所有元素,注意删除之后保留的元素包含两端的start和end索引值。


    我们这里举例测试:


    我们构造了一个名为yujie_list的列表类型数据结构,从左边依次压入:0 1 2 3 4 5 6 7 8 9

    最后从左到右依次列出列表中的所有元素如上图所示。


    接下来我们测试lrange和ltrim命令如下图:


    我们使用lrange yujie_list 0 3命令,从左到右依次列出从索引0到索引3的元素,注意包含了索引0 值为9和索引3值为6的元素。

    我们使用ltrim yujie_list 4 -1命令,删除索引4到最右端之外的所有元素,注意删除的元素不包含索引4职位5的元素。

    好了原理讲完了,接下来我们上代码:

    RedisUtil是一个工具类,用于连接redis服务端。

    /**
     * 连接redis服务的工具类
     * @author yujie.wang3
     *
     */
    public final class RedisUtil {
        
        //Redis服务器IP
        private static String ADDR = "10.4.36.93";
        
        //Redis的端口号
        private static int PORT = 6379;
       
        
        //可用连接实例的最大数目,默认值为8;
        //如果赋值为-1,则表示不限制;如果pool已经分配了maxActive个jedis实例,则此时pool的状态为exhausted(耗尽)。
        private static int MAX_ACTIVE = 100;
        
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例,默认值也是8。
        private static int MAX_IDLE = 20;
        
        //等待可用连接的最大时间,单位毫秒,默认值为-1,表示永不超时。如果超过等待时间,则直接抛出JedisConnectionException;
        private static int MAX_WAIT = 10000;
        
        private static int TIMEOUT = 10000;
        
        //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
        private static boolean TEST_ON_BORROW = true;
        
        private static JedisPool jedisPool = null;
        
        /**
         * 初始化Redis连接池
         */
        static {
            try {
                JedisPoolConfig config = new JedisPoolConfig();
                config.setMaxActive(MAX_ACTIVE);
                config.setMaxIdle(MAX_IDLE);
                config.setMaxWait(MAX_WAIT);
                config.setTestOnBorrow(TEST_ON_BORROW);
                jedisPool = new JedisPool(config, ADDR, PORT);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 获取Jedis实例
         * @return
         */
        public synchronized static Jedis getJedis() {
            try {
                if (jedisPool != null) {
                    Jedis resource = jedisPool.getResource();
                    return resource;
                } else {
                    return null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        
        /**
         * 释放jedis资源
         * @param jedis
         */
        public static void returnResource(final Jedis jedis) {
            if (jedis != null) {
                jedisPool.returnResource(jedis);
            }
        }
    }

    测试类如下:

    /**
     * 一次返回多个列表值并删除返回值测试类
     * @author yujie.wang
     *
     */
    public class RedisTest {
    
    	public static void main(String[] args) {
    		String key = "yujie_test_list";
    		initList(key,9);
    		printList(key,"原始列表数据");
    		List<String> listResult = getListMultValueAfterDel(key,0,3);
    		System.out.println("一次返回并删除数据:"+listResult.toString());
    		printList(key,"删除之后列表数据");
    	}
    	
    	public static void initList(String key,int maxValue){
    		Jedis client = RedisUtil.getJedis();
    		for(int i = 0;i <= maxValue; i++){
    			client.lpush(key, String.valueOf(i));
    		}
    		System.out.println("初始化列表:"+ key + "完毕");
    	}
    	
    	public static void printList(String key,String message){
    		Jedis client = RedisUtil.getJedis();
    		List<String> list = client.lrange(key, 0, -1);
    		System.out.println(message+ " : " + list.toString());
    	}
    	
    	@SuppressWarnings("unchecked")
    	public static List<String> getListMultValueAfterDel(String key,int start, int end){
    		List<Object> list = null;
    		List<String> listStr = new ArrayList<String>();
    		try {		
    			Jedis jedis = RedisUtil.getJedis();
    			Transaction ts = jedis.multi();
    			ts.lrange(key, start, end);
    			ts.ltrim(key, end+1, -1);
    			list = ts.exec();
    			RedisUtil.returnResource(jedis);
    		} catch (Exception e) {
    			// TODO: handle exception
    			System.out.println(e);
    		}
    		if(list != null && !list.isEmpty()){
    			try {
    				//获得命令lrange(key, start, end)的返回结果
    				listStr =  (ArrayList<String>)list.get(0);	
    			} catch (Exception e) {
    				// TODO: handle exception
    				System.out.println(e);
    			}			
    		} else {
    			return Collections.emptyList();
    		}
    		return listStr;
    	}
    	
    }	

    输出结果:




    展开全文
  • 给定个整数数组,返回两个数字的索引,使它们相加到个特定的目标。 您可以假设每个输入都只有个解决方案,而您可能不会使用相同的元素两

    Given an array of integers, return indices of the two numbers such that they add up to a specific target.

    You may assume that each input would have exactly one solution, and you may not use the same element twice.

    (译:给定一个整数数组,返回两个数字的索引,使它们相加得到一个特定目标值。
    您可以假设每个输入都只有一个解决方案,而您可能不会使用相同的元素两次。)

    Example:

    Given nums = [2, 7, 11, 15], target = 9,
    
    Because nums[0] + nums[1] = 2 + 7 = 9,
    return [0, 1].

    实现:用hashmap实现是比较方便的,可以用函数直接找出是否包含某一数值

    import java.util.HashMap;
    import java.util.Map;
    
    public class twoSum {
    	public static int[] twoSum(int[] nums, int target) {
    		int[] result = new int[2];
            Map<Integer,Integer> map = new HashMap();
            for(int i=0; i<nums.length; i++){
                if(map.containsKey(target - nums[i])){
                	if(map.get(target - nums[i]) > i){
                		result[0] = i;
                		result[1] = map.get(target - nums[i]);
                	}else{
                		result[1] = i;
                		result[0] = map.get(target - nums[i]);
                	}
                	return result;
                }
                map.put(nums[i], i);
            }
            return result;
        }
    	
    	public static void main(String[] args) {
    		int[] nums = {3,2,4};
    		int target = 6;
    		int[] result = new int[2];
    		result = twoSum(nums,target);
    		System.out.println(result[0] + " " + result[1]);
    	}
    }

    展开全文
  • 给定个整数数组 nums和个目标 target,请你在该数组中找出和为目标的那两个整数,并返回他们的数组下标。 你可以假设每种输入只会对应个答案。但是,你不能重复利用这个数组中同样的元素。 示例: 给.....

    题目链接:https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-2/

    给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标。

    你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。

    示例:

    给定 nums = [2, 7, 11, 15], target = 9
    
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]

    思路:(1)暴力法,遍历每个元素 x,并查找是否存在一个值与 target−x 相等的目标元素。

    class Solution 
    {
        public int[] twoSum(int[] nums, int target) 
        {
            for(int i=0; i<nums.length; i++)
            {
                for(int j=i+1; j<nums.length; j++)
                {
                    if(target - nums[i] == nums[j])
                        return new int[]{i,j};
                }
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    }

    (2)hashmap两次迭代

    在第一次迭代中,我们将每个元素的值和它的索引添加到表中。

     把数值作为 key,把数值所在的下标作为 value
    

    然后,在第二次迭代中,我们将检查每个元素所对应的目标元素(target - nums[i])  是否存在于表中。

    注意,该目标元素不能是 nums[i]本身!

    用到的函数的意义:

    containsKey(Object key) 
    返回值类型:boolean   如果此映射包含对于指定键的映射关系,则返回 true。
    
    put(K key, V value) 
    在此映射中关联指定值与指定键。
    
    get(Object key) 
    返回指定键所映射的值;如果对于该键来说,此映射不包含任何映射关系,则返回 null。
    class Solution 
    {
        public int[] twoSum(int[] nums, int target) 
        {
            Map<Integer,Integer> hash = new HashMap<Integer, Integer>();
            for(int i=0; i<nums.length; i++)
            {
                hash.put(nums[i], i);
            }
            for(int i=0; i<nums.length; i++)
            {
                if(hash.containsKey(target - nums[i]) && hash.get(target - nums[i]) != i)
                    return new int[]{i, hash.get(target - nums[i])};
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    }

     (3)hashmap一次迭代

    在进行迭代并将元素插入到表中的同时,我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在,那我们已经找到了对应解,并立即将其返回。

    class Solution {
        public int[] twoSum(int[] nums, int target) 
    {
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) 
            {
                int complement = target - nums[i];
                if (map.containsKey(complement)) 
                {
                    return new int[] { map.get(complement), i };
                }
                map.put(nums[i], i);
            }
            throw new IllegalArgumentException("No two sum solution");
        }
    }
    

     

    展开全文
  • C++ 利用指针和结构体实现个函数返回个值

    千次阅读 多人点赞 2017-03-22 21:07:14
    介绍利用指针与利用结构体作为函数的返回值,实现个函数返回个值

    在函数执行到return语句时,将不再向下执行,那么如何让函数一次性返回多个值?
    一般可以用两种方式解决这个问题,利用指针和利用结构体

    1.利用指针
    直接上代码:

    #include <iostream>
    using namespace std;
    int main()
    {
        
    	int* test(int,int,int);
    	int * result =test(1,2,3);
    	 cout<<result[0]<<endl<<result[1]<<endl<<result[2]<<endl;
          getchar();
    	  return 0;
    } 
    
    int * test(int a,int b,int c)
    {
    	int* presult =new int[3];
    	presult[0] =a;
    	presult[1] =b;
    	presult[2] = c;
    	return presult;
    }
    

    运行结果:
    1
    2
    3

    可以看到,我们其实定义了一个int类型的指针作为函数test的类型,所以这个函数的返回值也应该是一个int类型的指针,所以在第15行,我们定义了一个presult指针,并让它指向一个三个元素的数组。**(在这里,其实我们并没有定义数组,而是使用了动态内存分配的方式)**然后将三个形参分别写入到数组里,最后将指针作为函数的返回值返回。显然这个函数的功能是没有意义的,在这里只做演示而已。

    利用指针作为函数的返回值的方式有一个很大的弊端,不管返回几个值,他们的类型都是相同的。所以为了避免这个问题,我还需要另一种方式,利用结构体。

    2.利用结构体

    还是先上代码:

    #include <iostream>
    using namespace std;
    struct result
    {
    	int first;
    	double second;
    };
    int main()
    {
         result test(int a,double b);
         result returnvalue =test(1,2.1234);
    	 cout<<returnvalue.first <<endl<<returnvalue.second<<endl;
          getchar();
    	  return 0;
    } 
    
    result test(int a,double b)
    {
    	 struct result ret;
    	 ret.first  = a;
    	 ret.second = b;
    	 return ret;
    }
    
    

    运行结果:
    1
    2.1234
    结构体是C语言中的一种允许用户自定义的数据结构,其关键词为struct 。首先,我们定义了一个结构体类型叫result,它里面包含两个成员分别为int类型的first与double类型的second。
    我们可以这样理解结构体类型,定义之后,result与int,double,float等C语言自带的数据类型没有区别,只不过这个result使我们自己定义的而已,更多关于结构体的内容可以参考:
    http://blog.csdn.net/chaipp0607/article/category/6627824
    然后,我们定义的函数test其实就是一个result类型的函数,定义的变量ret和returnvalue 也是result类型的变量,test的返回值当然也是一个result类型的值。我们利用result类型的变量–returnvalue 中的成员,区分开int和double,实现返回值的类型不同。

    展开全文
  • C语言如何让个函数返回个值

    万次阅读 2018-12-13 22:11:08
    2.或是你根本就不要返回,设置一个宏观变量(全局变量),主函数和子函数都使用,就不用返回了 3.返回指针怎么办呢?————使用指向指针的指针返回。 二、代码展示: 1.用指针和数组(数组名本...
  • java 个函数如何返回个值

    千次阅读 2016-07-14 20:13:49
    在开发过程中,经常会有这种情况,就是个函数需要返回个值,这是个问题!! 网上这个问题的解决方法: 1、使用map返回值;这个方法问题是,你并不知道如何返回值的key是什么,只能通过doc或者通过源代码...
  • return 只能返回一个值,若要 return返回个值,则要使用return返回对象的方式? <script> functiongetRect(_w,_h){ var_perimeter=_w*2+_h*; var_area=_w*_h; return{//返回的是个对象,对象的...
  • demo.py(函数返回多个值(元组)): # 定义函数,有多个返回值(返回元组) def measure(): """测量温度和湿度"... # 元组-可以包含多个数据,因此可以使用元组让函数一次返回个值 # 如果...
  • 在子进程创建之后,父子进程会共享份代码内容,即子进程为父进程的拷贝,因此在父进程和子进程中程序都往下继续执行,子进程的fork会返回一个值,而父进程的fork也会返回一个值,通过返回值的不同就可以区分父进程...
  • 给定个整数数组,找出其中两个数相加等于目标  例如:给定数组及目标 nums = [2,7,11,15] ,target = 9  因为nums[0] + nums[1] = 2 + 7 = 9  返回[0,1] /** * 使用辅助空间(使用哈希表,时间复杂度是O...
  • 一次调用,两次返回-------fork函数学习总结  以前一直迷惑,什么叫一次调用,两次返回。通过上网搜索,终于知其原由。现将自己的理解记录于此。  准备知识:  内存中的进程包括三部分:可执行文件(即程序...
  • 给定个数组,求两个数之和=给定sum的所有组合个数。 【变形】两个数之和=sum的任意组数 【方法】穷举法 从数组中任意找两个数,看其和是否=sum。时间复杂度O(N^2) 【方法二】先排序,然后定义两个指针,...
  • 给定个整数数组 nums 和个目标 target,请你在该数组中找出和为目标的那两个整数,并返回他们的数组下标。 你可以假设每种输入只会对应个答案。但是,你不能重复利用这个数组中同样的元素。 示例: ...
  • 结果今天这题目引发我了我的一个问题,题目如下: 5数求最值 时间限制:1000 ms | 内存限制:65535 KB 难度:1 描述设计一个从5整数中取最小数和最大数的程序 输入输入只有组测试数据,为五不...
  • java:函数--返回个值

    万次阅读 2017-10-07 17:21:50
    在开发过程中,经常会有这种情况,就是个函数需要返回个值,这是个问题!! 网上这个问题的解决方法: 1、【使用集合类】使用map返回值;这个方法问题是,你并不知道如何返回值的key是什么,只能通过doc或者...
  • 如何让函数同时返回个值

    千次阅读 2019-03-29 08:06:52
    一般而言,个函数只返回一个值,但有时候可能需要函数同时返回个值。解决办法一般有种,是定义个新的数据类型,二是使用引用形参。 举个栗子,比如我们需要函数fun()返回商品的价格以及商品现存数量, ...
  • Python之函数如何返回个值

    万次阅读 2019-03-31 00:21:40
    2、这里有个误区,多个值,真的是多个,而不是说返回一个ArrayList之类容器,或者其他容器对象啊,真的就是多个值 3、例子 >>> def fkMulti(): ... a = 5 ... b = 10 ... return a,b ... >>>...
  • *方法:暴力法: public static int[] twoSum01(int[] nums, int target) { for(int i = 0; i &amp;amp;amp;amp;amp;lt; nums.length; i++) { for(int j = i + 1; j &amp;amp;amp;amp;amp;lt; nums....
  • 给定个整数数组和个目标,找出数组中和为目标两个数。 你可以假设每 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 个输入只对应种答案,且...
  • for (var i = 0; i < 10; i++) { setTimeout(function(){ console.log(i);...// 输出十 10 for (let j = 0; j < 10; j++) { setTimeout(function(){ console.log(j); }) } // 输出 0123456789...
  • 给定个整数数组和个目标,找出数组中和为目标两个数。 你可以假设每个输入只对应种答案,且同样的元素不能被重复利用。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 ...
  • python- 如何return返回个值

    千次阅读 2019-08-24 20:43:29
    函数的return 语句只能返回一个值,可以是任何类型。 因此,我们可以“返回一个 tuple类型,来间接达到返回个值 ”。 例: x 除以 y 的余数与商的函数 def F1 ( x, y ): a = x % y b = (x-a) / y return ( a,b...
  • 快速找出个数组中的两个数字,让这两个数字之和等于个给定的,为了简化起见,我们假设这个数组中肯定存在至少组符合要求的解。  假如有如下的两个数组,如图所示:  5,6,1,4,7,9,8  
  • 查看zip文档: 直译过来就是:zip()函数返回一个zip对象,其.__ next__()方法返回一个元组,其中第i元素来自第i可迭代参数。__ next __()方法一直持续到参数序列中最短的可迭代耗尽,然后引发StopIteration。 也...
  • 从C++函数返回个值

    万次阅读 2017-06-30 11:42:10
    作者:Eli Bendersky ... 因为C++没有内置的从函数或方法返回个值的语法,程序员在需要时使用各种技术来模拟之,而自C++11的引入,这个...在本文里,我想提供我们今天所拥有的从函数返回个值的某些选择的个概况,
  • 方法:使用最容易理解的遍历数组进行查找 def solution(nums,target): #如果列表长度小于2,则直接结束 if len(nums) &lt; 2: return #两次循环列表,分别对列表中的所有可能的数字进行相加 #循环两次...
  • MFC 两个窗口 传递

    千次阅读 2017-02-27 21:44:40
    身边的小伙伴又有人入坑MFC ,(我都已经 好久不碰这玩意儿了)今天问我怎么在两个窗口之间传值。接着上次,做一次总结(也是怕自己今后忘了,万一哪天需要,又拿起MFC了 ) ///// ---- 2018年3月4日20:01:08 更新=...
  • 给定个整数数组nums和个目标target,请你在该数组中找出和为目标的那两个整数,并返回他们的数组下标。你可以假设每种输入只会对应个答案,但是你不能重复利用数组中的同样的元素。 var getIndex = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,599,166
精华内容 639,666
关键字:

一次返回两个值