精华内容
下载资源
问答
  • 利用一个小技巧,一个整数a在异或另一个整数b两次以后所得的值还是整数a。...下面给出交换两个整数位置的代码,不需要临时变量temp。 public class Aa { public static void main(String[] args) { in...

    利用一个小技巧,一个整数a在异或另一个整数b两次以后所得的值还是整数a。

    具体的过程我们可以自己找两个整数以二进制的形式自己在纸上画一下他们的异或过程。(异或的运算符号为"^")

    比如:

     

    下面给出交换两个整数位置的代码,不需要临时变量temp。

    public class Aa {
    	public static void main(String[] args) {
    		int a = 3, b = 5;
    		System.out.println("before swap:" + "a=" + a + ",b=" + b);
    		// 开始交换位置
    		a = a ^ b;  
    		b = a ^ b; // b=a^b^b=a
    		a = a ^ b; // a=a^b^a^b^b=b
    		System.out.println("after swap:" + "a=" + a + ",b=" + b);
    	}
    }
    

    运行结果:

    before swap:a=3,b=5
    after swap:a=5,b=3

     

    转载于:https://www.cnblogs.com/kkkky/p/7741604.html

    展开全文
  • package com.handy.ds; public class SwapWithoutTemp { /**Author:handy 2012/3/20 15:14 * @param args */ private int a; private int b;... public static void main(String[] args) { // TODO Auto-g
    package com.handy.ds;
    
    public class SwapWithoutTemp {
    
    	/**Author:handy 2012/3/20 15:14
    	 * @param args
    	 */
    	private int a;
    	private int b;
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		SwapWithoutTemp swt = new SwapWithoutTemp();
    		swt.a = 100;
    		swt.b = 200;
    		System.out.println("Before swap,a=" + swt.a + ",b=" + swt.b);
    		// swt.swap1();
    		swt.swap2();
    		System.out.println("After swap,a=" + swt.a + ",b=" + swt.b);
    	}
    
    	public void swap1() {
    
    		a = (a ^ b);
    		b = (a ^ b);
    		a = (b ^ a);
    
    	}
    
    	public void swap2() {
    		a = (a + b);
    		b = (a - b);
    		a = (a - b);
    
    	}
    }
    

    展开全文
  • package com.interview.datastructure; public class SelectSort { public static void sort(int[] a) { if (a != null) { for (int i = 1; i < a.length; i++) { int tmp = a[i], j = ...
    package com.interview.datastructure;
    
    public class SelectSort {
    public static void sort(int[] a) {
        if (a != null) {
            for (int i = 1; i < a.length; i++) {
                int tmp = a[i], j = i;
                if (a[j - 1] > tmp) {
                    while (j >= 1 && a[j - 1] > tmp) {
                        a[j] = a[j - 1];
                        j--;
                    }
                }
                a[j] = tmp;
            }
        }
    }
    
    public static void main(String[] args) {
        int[] array = {1, 6, 8, 2, 5, 3};
        sort(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    } }
    

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 本系列来自《java 重构...如:将一个临时变量temp保存到某一个表达式的运行结果。 做法将这个表达式提炼到一个独立函数(所谓查询式:Query),将这个临时变量的所有替换为新函数的调用。新函数可以被其它地方引用。

    本系列来自《java 重构改善既有代码的设计》一书

    如:将一个临时变量temp保存到某一个表达式的运行结果。

    做法将这个表达式提炼到一个独立函数(所谓查询式:Query),将这个临时变量的所有替换为新函数的调用。新函数可以被其它地方引用。

    public double getPrice(){
    	double basePrice = itemPrice * quantity;
    	if(basePrice > 1000) {
    		return basePrice * 0.95;
    	} else {
    		return basePrice * 0.98;
    	}
    }
    可以写成:

    public double getPrice() {
    	if (basePrice() > 1000) {
    		return basePrice() * 0.95;
    	} else {
    		return basePrice() * 0.98;
    	}
    }
    
    public double basePrice() {
    	return itemPrice * quantity;
    }
    考虑到临时变量只是暂时的,而且只能在所属函数内部使用,由于临时变量只有在所属函数内部使用,所以会驱使你写出更长的函数,因为只有这样你才能访问到要访问的临时变量。而如果把临时变量替换成为一个查询式(query method),那么同一个类的所有函数都能获取这份信息。

    以查询替换临时变量往往是提炼方法(Extract Method)前必不可少的步骤,因为局部变量会让代码难以提炼,所以应该尽可能把他们替换成查询式。

    做法:

    1、找出只被赋值一次的临时变量(如果某个变量被赋值超过一次,考虑使用Split Temppopary Variable(解剖临时变量)将它分解成多个变量)。

    2、将该变量申明为final(final只能被赋值一次)

    3、编译(可以确保该临时变量确实只被赋值一次)。

    4、将对该临时变量赋值的语句等号右侧部分提炼到一个独立的函数中(首先将它申明为private,如果后续有其他class需要调用,可以取消保护。同时要确保提炼出来的函数无任何连接影响,即该函数并不修改任何对象的内容)。

    5、编译测试,并在临时变量上实施Inline Temp。

    例:

    public double getPrice() {
    	int basePrice = quantity * itemPrice;
    	double discountFactor;
    	if (basePrice() > 1000) {
    		discountFactor = 0.95;
    	} else {
    		discountFactor = 0.98;
    	}
    	return basePrice * discountFactor;
    }
    尽管代码十分清楚,依然将临时变量加上final,检查他们是否的确只被赋值一次。然后编译运行,这样处理的话如果没有问题,编译器就不会警告。之所以这样,是因为如果这个变量不只被赋值一次,那么我们就不能进行这次重构。

    接下来就是提炼Query Method:

    public double getPrice() {
    	final int basePrice =  basePrice();
    	final double discountFactor;
    	if (basePrice() > 1000) {
    		discountFactor = 0.95;
    	} else {
    		discountFactor = 0.98;
    	}
    	return basePrice() * discountFactor;
    }
    
    private int basePrice() {
    	return itemPrice * quantity;
    }
    接下来将临时变量内联化,删除临时变量:

    public double getPrice() {
    	final double discountFactor;
    	if (basePrice() > 1000) {
    		discountFactor = 0.95;
    	} else {
    		discountFactor = 0.98;
    	}
    	return basePrice() * discountFactor;
    }
    同样的道理,提取discountFactor的Query Method

    public double getPrice() {
    	return basePrice() * discountFactor();
    }
    
    private int basePrice() {
    	return itemPrice * quantity;
    }
    
    private double discountFactor() {
    	if (basePrice() > 1000) {
    		return 0.95;
    	}
    	return 0.98;
    }
    这是我们发现:如果没有将basePrice替换成一个查询表达式,将多么难提炼discountFactor().




    展开全文
  • 一、动机 多半作为Replace Temp with Query的一部分使用。... 3、找到该临时变量的所有引用点,将它们替换为临时变量赋值的表达式。 4、修改为所有引用点后,删除该临时变量的声明和赋值语句。...
  • 内联临时变量(Inline Temp) 你有一个临时变量,只被一个简单表达式赋值一次,而它妨碍了其他重构手法。将所有对该变量的引用动作,替换为对它赋值的那个表达式自身 一、动机 1、作为“以查询取代临时变量”的一...
  • 该方法通常被作为 6.4 Replace Temp with Query 以查询取代临时变量 的前置条件使用 动机 某个临时变量被赋予了某个方法的返回值 案例 public double getBasePrice() { double basePrice ...
  • double basePrice = order.getPrice(); return basePrice; 改成 returnorder.getPrice(); 去掉临时无用的临时变量 转载于:https://www.cnblogs.com/yangming0322/p/9102636.html
  • 以查询取代临时变量(Replace Temp with Query) 你的程序以一个临时变量保存某一个表达式的结果。将这个表达式提炼到一个独立函数中,将这个临时变量所有的引用点替换为对新函数的调用,此后,新函数就可以被其他...
  • 创建临时变量交换两个数的值,只需要创建一个临时变量temp就可以做到。 相关代码: #include int main() { int n = 10; int m = 50; int temp = 0; printf("n = %d m = %d\n", n, m); temp = n; n = m; m...
  • 一、用法 你的程序以一个临时变量保存某一表达式...由于临时变量只在所属函数内可见,所以它们会驱使你写出更长的函数,因为只有这样你才能访问到需要的临时变量、如果把临时变量替换为一个查询,那么同一个类中的所有
  • 博客搬到了fresky.github.io - Dawei XU,请各位看官挪步。最新的一篇是:为什么在Windows有两个临时文件夹的环境变量Temp和Tmp?。 转载于:https://www.cnblogs.com/fresky/p/4437847.html...
  • 临时变量只被赋值一次,校验是否只被赋值一次方式,将临时变量修饰符改成final类型,编译器无报错则证明只被赋值一次。 临时变量提到单独查询函数中,保证其他引用方法,不用写重复代码。 二 使用实例 //包含...
  • 临时变量时暂时的,只能在所属函数内使用,所以它们会驱使你写出更长的函数。 将临时变量替换为一个查询,那么同一个类中的所有函数豆浆可以获得这份信息,是你能够为这个类编写更清晰的代码。 二、做法 1、...
  • 概括一个临时变量,只被一个简单表达式赋值一次,而它妨碍了其他重构方法。将所有对该变量的引用替换为对它赋值的那个表达式本身。 例子double basePrice = anOrder.basePrice();return (basePrice > 1000)重构...
  • 将表达式提炼到一个独立方法中,将这个临时变量的所有引用点替换为对新方法的调用 更多精彩 更多技术博客,请移步 asing1elife’s blog 前置条件 该方法通常是 6.1 Extract Method 提炼方法 的前置条件 ...
  • 你有一个临时变量,只被一个简单表达式赋值一次,而它妨碍了其他重构手法。将所有对该变量的引用动作,,替换为对它赋值的那个表达式自身 double basePrice = anOrder.BasePrice(); return basePrice(&...
  • 当你的程序以一个临时变量保存某一表达式的运算结果 将这个表达式提炼到一个独立函数中,将这个临时变量的所有[被引用点]替换为[对新函数的调用],新函数可被其他函数使用 java 代码 double basePrice=_...
  • 你的程序以一个临时变量保存某一表达式的运算结果;将这个表达式提炼到一个独立函数中,将这个临时变量的所有引用点替换为对新函数的调用。此后,新函数就可被其他函数使用; 动机 临时变量的...
  • 利用一个小技巧,一个整数a在异或另一个整数b两次以后所得的值还是整数a...下面给出交换两个整数位置的代码,不需要临时变量temp。运行结果: public class Aa {  public static void main(String[] args) ...
  • 你的程序以一个临时变量保存某一表达式的运算结果 将这个表达式提炼到一个独立函数中。将这个临时变量的所有引用点替换为对新函数的调用。此后,新函数就可以被其他函数使用。 double basePrice=_quantity*_item...
  • 错误示范: 源代码 #include<stdio.h> #include<Windows.h> //错误示范 //void swap2(int a2, int b2) ...// int temp = a2;...// b2 = temp;...//创建临时变量法 ...//不创建临时变量时的两种办法
  • 交换临时变量

    2021-02-21 12:42:48
    1、创建临时变量交换ab的值 void exchange_ab(int x,int y) { int temp = 0; temp = x; x = y; y = temp; } int main() { int a = 0; int b = 0; scanf("%d%d", &a, &b); exchange_ab(a, b); ...
  • 固定思维通常是需要一个临时变量temp,如果没有这个临时变量呢,其实也不复杂,:) inline void swap(int &a, int &b) /*C用指针吧*/ { a = a + b; b = a - b; a = a - b; } 这里相当用a来存储...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,495
精华内容 598
关键字:

临时变量temp