class Heater { //加热器
    ...
}
class Pump { //泵
    private Heater heater;
    ...
}

class CoffeeMaker {
    private Heater heater;
    private Pump pump;
    //相比在对象内部自己创建，而是交给外部注入
    public CofeeMaker(Heater heater, Pump pump) {
        this.heater = heater;
        this.pump = pump;
    }
    void brew() {
    }
}

public NotificationPanelViewController(NotificationPanelView view,
            @Main Handler handler,
            @ShadeDisplayAware LayoutInflater layoutInflater,
            FeatureFlags featureFlags,
            ......此处省略约80行
            NaturalScrollingSettingObserver naturalScrollingSettingObserver,
            MSDLPlayer msdlPlayer,
            BrightnessMirrorShowingInteractor brightnessMirrorShowingInteractor) {
            
            ....
            }

class Heater {
    ...
}
class Pump {

    
    public Heater heater;
    
    @Inject
    public Pump(Heater heater) {
    this.pump = pump;
    }
}

class CoffeeMaker {
    private Heater heater;
    private Pump pump;
    
    @Inject
    public CofeeMaker(Heater heater, Pump pump) {
        this.heater = heater;
        this.pump = pump;
    }
    ...
}

@Module
abstract class HeaterModule {

    @Provider
    public static Heater provideHeater() {
        return new Heater();
    }
    
}

interface Heater {
    ...
}
class ElectricHeater implements Heater {
    ...
}
class GasHeater implements Heater {
    ...
}

interface Pump {
    
}
class Thermosiphon implements Pump { // 假设这是非叶子节点
    ...
}
class ElectricPump implements Pump { // 假设这是非叶子节点
    ...
    @Inject
    public ElectricPump (Heater heater) {...}
}

@Component(modules = HeaterModule.class)
interface CoffeeShop {

    @Component.Builder
    interface builder{
        CoffeShop build();
    }
    CoffeeMaker maker();
}

编译产物
@DaggerGenerated
@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes",
    "KotlinInternal",
    "KotlinInternalInJava",
    "cast",
    "deprecation",
    "nullness:initialization.field.uninitialized"
})
public final class DaggerCoffeeShop {
  private DaggerCoffeeShop() {
  }

  public static CoffeeShop.Builder builder() {
    return new Builder();
  }

  public static CoffeeShop create() {
    return new Builder().build();
  }

  private static final class Builder implements CoffeeShop.Builder {
    @Override
    public CoffeeShop build() {
      return new CoffeeShopImpl();
    }
  }

  private static final class CoffeeShopImpl implements CoffeeShop {
    private final CoffeeShopImpl coffeeShopImpl = this;

    private CoffeeShopImpl() {


    }

    private ElectricPump electricPump() {
      return new ElectricPump(HeaterModule_ProvideElectricHeaterFactory.provideElectricHeater());
    }

    @Override
    public CoffeeMaker maker() {
      return new CoffeeMaker(HeaterModule_ProvideElectricHeaterFactory.provideElectricHeater(), electricPump());
    }
  }
}

@Component(modules = DripCoffeeModule.class)
@Singleton
interface CoffeeShop {
    CoffeeMaker maker();
}

@Module
abstract class HeaterModule {
  @Provider
  @ActivityScope // 在此处+ @Singleton
public static Heater provideElectricHeater() {
    return new ElectricHeater();
}
}

@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScope {}

//编译后
public Map<Class<?>, javax.inject.Provider<CoreStartable>> getStartables() {
    return MapBuilder.newMapBuilder(109)
    .put(NotificationLogger.class, this.provideCoreStartableProvider)
    .put(ShortcutHelperActivityStarter.class, this.starterProvider)
    .put(ShortcutHelperRepository.class, this.repoProvider)
        .........
    .put(BroadcastDispatcherStartable.class, this.broadcastDispatcherStartableProvider)
    .put(Recents.class, this.volumeUIProvider).build();
}

@Binds
@IntoMap
@ClassKey(ForegroundServicesDialog.class)
public abstract Activity bindForegroundServicesDialog(ForegroundServicesDialog activity);

public interface GlobalRootComponent {

    /**
     * Builder for a GlobalRootComponent.
     */
    interface Builder {
        @BindsInstance
        Builder context(Context context); //绑定Context到依赖库 
        @BindsInstance
        Builder instrumentationTest(@InstrumentationTest boolean test);
        GlobalRootComponent build();
    }
}

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

@AssistedInject //声明这是一个辅助注入类型
public DelayedWakeLock(@Background Lazy<Handler> bgHandler,
                       @Main Lazy<Handler> mainHandler,
                       Context context, WakeLockLogger logger,
        @Assisted String tag) { // 声明该参数由用户传入
    mInner = WakeLock.createPartial(context, logger, tag);
    mHandler = Flags.delayedWakelockReleaseOnBackgroundThread() ? bgHandler.get()
            : mainHandler.get();
}
...
@AssistedFactory //声明助理工厂，编译中DelayedWakeLock的构造方法根据自动生成动态依赖String tag的方法
public interface Factory {
    /** creates the instance of DelayedWakeLock class. */
    DelayedWakeLock create(String tag);
}

//SystemUIAppComponentFactoryBase.kt  --> AppComponentFactory.java

override fun instantiateApplicationCompat(cl: ClassLoader, className: String): Application {
    val app = super.instantiateApplicationCompat(cl, className)
    if (app !is ContextInitializer) {
        throw RuntimeException("App must implement ContextInitializer")
    } else {
        app.setContextAvailableCallback { context -> //设置一个在onCreate方法中执行的回回调函数
            createSystemUIInitializerInternal(context)
        }
    }
    return app
}

private fun createSystemUIInitializerInternal(context: Context): SystemUIInitializer {
    return systemUIInitializer ?: run {
        val initializer = createSystemUIInitializer(context.applicationContext)
        try {
            initializer.init(false) // 重点在这
        } catch (exception: ExecutionException) {
            throw RuntimeException("Failed to initialize SysUI", exception)
        } catch (exception: InterruptedException) {
            throw RuntimeException("Failed to initialize SysUI", exception)
        }
        initializer.sysUIComponent.inject(
            this@SystemUIAppComponentFactoryBase
        )

        systemUIInitializer = initializer
        return initializer
    }
}

//SystemUIInitializer.java

public void init(boolean fromTest) throws ExecutionException, InterruptedException {
    mRootComponent = getGlobalRootComponentBuilder()
            .context(mContext)
            .instrumentationTest(fromTest)
            .build();

    mInitializationChecker = mRootComponent.getInitializationChecker();
    boolean initializeComponents = mInitializationChecker.initializeComponents();

    // Stand up WMComponent
    setupWmComponent(mContext); // 初始化 mWMComponent

    // And finally, retrieve whatever SysUI needs from WMShell and build SysUI.
    SysUIComponent.Builder builder = mRootComponent.getSysUIComponent();
    // 将WMShell 模块核心依赖添加到 ApplicationSingeton scope中
    if (initializeComponents) {
        // Only initialize when not starting from tests since this currently initializes some
        // components that shouldn't be run in the test environment
        builder = prepareSysUIComponentBuilder(builder, mWMComponent)
                .setShell(mWMComponent.getShell())
                .setPip(mWMComponent.getPip())
                .setSplitScreen(mWMComponent.getSplitScreen())
                .setOneHanded(mWMComponent.getOneHanded())
                .setBubbles(mWMComponent.getBubbles())
                .setTaskViewFactory(mWMComponent.getTaskViewFactory())
                .setShellTransitions(mWMComponent.getShellTransitions())
                .setKeyguardTransitions(mWMComponent.getKeyguardTransitions())
                .setStartingSurface(mWMComponent.getStartingSurface())
                .setDisplayAreaHelper(mWMComponent.getDisplayAreaHelper())
                .setRecentTasks(mWMComponent.getRecentTasks())
                .setBackAnimation(mWMComponent.getBackAnimation())
                .setDesktopMode(mWMComponent.getDesktopMode());

        // Only initialize when not starting from tests since this currently initializes some
        // components that shouldn't be run in the test environment
        mWMComponent.init();
    } else {
        ......
    }
    mSysUIComponent = builder.build();  // 实例化Component，(生成依赖关系图)

    // Every other part of our codebase currently relies on Dependency, so we
    // really need to ensure the Dependency gets initialized early on.
    Dependency dependency = mSysUIComponent.createDependency();
    dependency.start(); // 初始化全局仓库
}

//SystemUIApplication.java

@Override
public void onCreate() {
    super.onCreate();
    
    mInitializer = mContextAvailableCallback.onContextAvailable(this); // 初始化Component
    //获取子组件Component  scope: @SysUISingleton
    mSysUIComponent = mInitializer.getSysUIComponent();
    mBootCompleteCache = mSysUIComponent.provideBootCacheImpl();
    log.traceEnd();
    //获取根组件Component scope: @Singleton
    GlobalRootComponent rootComponent = mInitializer.getRootComponent();

    // Enable Looper trace points.
    // This allows us to see Handler callbacks on traces.
        ......
}

@SysUISingleton
public class KeyguardUpdateMonitor implements TrustManager.TrustListener, CoreStartable {

    @Inject
    protected KeyguardUpdateMonitor(
            Context context,
            UserTracker userTracker,
            @Main Looper mainLooper,
            BroadcastDispatcher broadcastDispatcher, // 以这个类为例
            DumpManager dumpManager,
            @Background Executor backgroundExecutor,
            @Main Executor mainExecutor,
            StatusBarStateController statusBarStateController,
            LockPatternUtils lockPatternUtils,
            AuthController authController,
            ......
    }
}

@SysUISingleton
open class BroadcastDispatcher @Inject constructor(
    private val context: Context,
    @Main private val mainExecutor: Executor,
    @BroadcastRunning private val broadcastLooper: Looper,
    @BroadcastRunning private val broadcastExecutor: Executor,
    private val dumpManager: DumpManager,
    private val logger: BroadcastDispatcherLogger,
    private val userTracker: UserTracker,
    private val removalPendingStore: PendingRemovalStore
) : Dumpable {

public class Sort {

    public static void main(String[] args) {
        int[] nums = new int[]{1,3,5,25,7,23,7,34,8,12,5,3,71,236,12};
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        // outputL: [1, 3, 3, 5, 5, 7, 7, 8, 12, 12, 23, 25, 34, 71, 236]
    }
}

public class Sort {


    public static void main(String[] args) {
        Integer[] nums = new Integer[]{1,3,5,25,7,23,7,34,8,12,5,3,71,236,12}; // 是包装类 Integer 不是int
        Arrays.sort(nums, Collections.reverseOrder());
        System.out.println(Arrays.toString(nums));
        // output: [236, 71, 34, 25, 23, 12, 12, 8, 7, 7, 5, 5, 3, 3, 1]
    }
}

@FunctionalInterface // 做个约束 改接口只能定义一个属于自己的抽象方法
public interface ShenComparator<T> {

    /**
     * 比较两个数的大小
     * @param o1 第一个数
     * @param o2 第二个数
     * @return > 0 ? 前面的数字大 ： 后面的数字大
     * NOTICE:: 这里不仅仅表示值 比如integer double 等数值 、
     * 可以表示一切对象按照指定规则比较大小
     *
     */

    int compare(T o1,T o2);
    
    // 该方法属于Object(出现在这里属于多余)
    boolean equals(Object obj);

}

// 实现类
// 如果 o1 > o2 结果自然大于零， o1 < o2 结果自然小于零, 如果将结果反序则得到的排序结果也是相反逻辑
int compare(Integer o1,Integer o2) {
    return o1 - o2;
    // return o2 - o1;
}

public class Utils {

    /**
     * 排序
     * @param nums 待排序的数组
     *                   而是一个具体的排序规则 ::
     *                   字符串有字符串的规则
     *                   数字类型有数字类型比较规则
     */
    public static  void  sort(int[] nums) {
        quickSort(nums,0,nums.length - 1);
    }


    private static  void quickSort(int[] nums,int left,int right) {
        if (left >= right)
            return;
        int pivot = partition(nums, left, right);
        quickSort(nums, left, pivot - 1);
        quickSort(nums, pivot + 1, right);
    }

    private static  void swap(int[] nums,int x, int y) {
        int mid = nums[x];
        nums[x] = nums[y];
        nums[y] = mid;
    }

    /* 哨兵划分 */
    private static  int partition(int[] nums, int left, int right) {
        // 以 nums[left] 作为基准数
        int i = left, j = right;
        while (i < j) {
            while (i < j && nums[j] >= nums[left])
                j--;
            while (i < j && nums[i] <= nums[left])
                i++;
            swap(nums, i, j);
        }
        swap(nums, i, left);
        return i;
    }
}

public class Main {

    private static final int[] nums = {43,1,56,7,23,12,46,23,8,9,4,23,56,30,23,5};
    public static void main(String[] args) {
        Utils.sort(nums);
        System.out.println(Arrays.toString(nums));
        // output: [1, 4, 5, 7, 8, 9, 12, 23, 23, 23, 23, 30, 43, 46, 56, 56]
    }
}

public class Utils {

    /**
     * 排序
     * @param nums 待排序的数组
     * @param comparator 排序规则比较器 传入不是具体的某一个数据
     *                   而是一个具体的排序规则 ::
     *                   字符串有字符串的规则
     *                   数字类型有数字类型比较规则
     */
    public static <T> void  sort(T[] nums, ShenComparator<T> comparator) {
        quickSort(nums,0,nums.length - 1,comparator);
    }


    private static <T> void quickSort(T[] nums,int left,int right,ShenComparator<T> comparator) {
        if (left >= right)
            return;
        int pivot = partition(nums, left, right,comparator);
        quickSort(nums, left, pivot - 1,comparator);
        quickSort(nums, pivot + 1, right,comparator);
    }

    private static <T> void swap(T[] nums,int x, int y) {
        T mid = nums[x];
        nums[x] = nums[y];
        nums[y] = mid;
    }

    /* 哨兵划分 */
    private static <T> int partition(T[] nums, int left, int right,ShenComparator<T> comparator) {
        // 以 nums[left] 作为基准数
        int i = left, j = right;
        while (i < j) {
            // 替换 nums[j] >= nums[left]
            while (i < j && comparator.compare(nums[j],nums[left]) >= 0)
                j--;
                // 替换nums[i] <= nums[left]
            while (i < j && comparator.compare(nums[i],nums[left]) <= 0)
                i++;
            swap(nums, i, j);
        }
        swap(nums, i, left);
        return i;
    }
}

public class Main {


    public static void main(String[] args) {

        Student[] students = new Student[]{
                new Student(18,"lip",99F),
                new Student(19,"dabbe",45.5F),
                new Student(20,"miky",50.5F)};

        Utils.sort(students, new ShenComparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 按照成绩从大到小排序
                return  (int)(o2.getScore() -  o1.getScore());
            }
        });
        System.out.println(Arrays.toString(students));
        //output:[Student(age=18, name=lip, score=99.0), Student(age=20, name=miky, score=50.5), Student(age=19, name=dabbe, score=45.5)]
    }
}

public class Main {


    public static void main(String[] args) {

        Student[] students = new Student[]{
                new Student(18,"lip",99F),
                new Student(19,"dabbe",45.5F),
                new Student(20,"miky",50.5F)};

        Utils.sort(students, (o1, o2) -> (int)(o2.getScore() -  o1.getScore())); // 只需要一行代码及可完成
        System.out.println(Arrays.toString(students));
    }
}

Utils.sort(students,(a,b) -> b.getName().compareTo(a.getName())); // 根据名字倒序排序

Utils.sort(students,(a,b) -> a.getAge() - b.getAge()); // 根据年龄正序排序

public class Main {


    @Data // 为了节省空间就不写setter getter构造方法了 直接用lombok 自动生成了
    @AllArgsConstructor
    static class Employee {
        private String name;
        private String department;
        private double salary;
    }

    public static void main(String[] args) {

        List<Employee> list = Arrays.asList(new Employee("Alice", "HR", 50000),
                new Employee("Bob", "Engineering", 60000),
                new Employee("Charlie", "HR", 55000),
                new Employee("David", "Engineering", 70000),
                new Employee("Eva", "HR", 48000),
                new Employee("Frank", "Sales", 75000));


        Map<String, Double> averageSalaryByDepartment  = list.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, // 按部门分组
                        Collectors.averagingDouble(Employee::getSalary))); // 求平均值

        averageSalaryByDepartment.forEach((department, salaryAVG) -> System.out.println("Department: " + department + ", Average Salary: " + salaryAVG));
        //output:Department: Engineering, Average Salary: 65000.0
				//Department: Sales, Average Salary: 75000.0
				//Department: HR, Average Salary: 51000.0
    }

}

package shen.dao;

import shen.entity.User;

public interface IUserDao {
    /*
    * 查找单个用户
    * */

    User findUserById(Integer id);
}

package shen.dao.impl;

import shen.dao.IUserDao;
import shen.entity.User;

public class UserDaoImpl implements IUserDao {

    @Override
    public User findUserById(Integer id) {

        User user = new User(0,"you catch me","Hi");
        return user;
    }
}

package shen.entity;

public class User {
    private Integer id;
    private String username;
    private String password;

    public User() {}
    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

package shen.handler;
import shen.dao.IUserDao;
import shen.dao.impl.UserDaoImpl;
import shen.entity.User;

public class ProxyHandler implements IUserDao {


    public void before() {
        System.out.println("turn on transaction");
    }
    @Override
    public User findUserById(Integer id) {
        this.before();
        UserDaoImpl userDao = new UserDaoImpl();
        User user = userDao.findUserById(id);
        System.out.println(user);
        this.after();
        return user;
    }
    public void after() {
        System.out.println("turn off transaction");
    }
}

package shen.test;

import shen.entity.User;
import shen.handler.ProxyHandler;

public class test {
    public static void main(String[] args) {
        IUserDao proxyHandler = new ProxyHandler();
        proxyHandler.findUserById(0);
    }
}
```output
turn on transaction
User{id=0, username='You catch me', password='Hi'}
turn off transaction

package shen.handler;

import shen.dao.IUserDao;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DaoTransactionHandler implements InvocationHandler {
//    if other class want use proxy  you can choose Object class
    private Object obj;

    public DaoTransactionHandler(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object res = null;
//        if you want to enhance just only one method
        if ("findUserById".equals(method.getName())) {
            this.before();
            res = method.invoke(obj,args);
            this.after();
        }else {
            res = method.invoke(args);
        }
        return res;
    }

    private void before() {
        System.out.println("turn on enhance transaction");
    }
    private void after(){
        System.out.println("turn off enhance transaction");
    }
}

package shen.test;

import shen.dao.IUserDao;
import shen.dao.impl.UserDaoImpl;
import shen.handler.DaoTransactionHandler;

import java.lang.reflect.Proxy;

public class test {
    public static void main(String[] args) {
//        target Class
        UserDaoImpl userDao = new UserDaoImpl();
//        enhance Class
//        invocation class
        DaoTransactionHandler daoTransactionHandler = new DaoTransactionHandler(userDao);
//        act proxy object
        IUserDao userDaoProxy =(IUserDao) Proxy.newProxyInstance(UserDaoImpl.class.getClassLoader(),
                UserDaoImpl.class.getInterfaces(), daoTransactionHandler);
        userDaoProxy.findUserById(0);

    }
}
```output
turn on enhance transaction
User{id=0, username='you catch me', password='Hi'}
turn off enhance transaction

package shen.test;

import shen.dao.IUserDao;
import shen.dao.impl.UserDaoImpl;
import shen.handler.DaoTransactionHandler;
import sun.misc.ProxyGenerator;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

public class test {
    public static void main(String[] args) {
//        target Class
        UserDaoImpl userDao = new UserDaoImpl();
//        enhance Class
//        invocation class
        DaoTransactionHandler daoTransactionHandler = new DaoTransactionHandler(userDao);
//        act proxy object
        IUserDao userDaoProxy =(IUserDao) Proxy.newProxyInstance(UserDaoImpl.class.getClassLoader(),
                UserDaoImpl.class.getInterfaces(), daoTransactionHandler);
        userDaoProxy.findUserById(0);
       // path such as "C:\\IdeaProject\\proxyDemo\\src"
        saveProxyClass("__your project path __\\src");

    }
    //writing $proxy to contain in localhost
    private static void saveProxyClass(String path) {
        byte[] $Proxy1s = ProxyGenerator.generateProxyClass("$Proxy1",
                UserDaoImpl.class.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(new File(path + "$Proxy1.class"));
            out.write($Proxy1s);
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (out != null) {
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }
}

public final class $Proxy1 extends Proxy implements IUserDao {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy1(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final User findUserById(Integer var1) throws  {
        try {
            return (User)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("shen.dao.IUserDao").getMethod("findUserById", Class.forName("java.lang.Integer"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
//import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;
import java.util.StringTokenizer;

/**
 * <城市，小计金额>
 *
 * <城市，{小计金额，小计金额...}>
 *
 * <城市，总计金额>
 */
public class accountByCity {
    public static class myMapper extends Mapper<Object,Text, Text, LongWritable> {
        private final static LongWritable account = new LongWritable();
        private Text city = new Text();
        private long startTime;
        @Override
        protected void setup(Context context)throws IOException,InterruptedException{
            super.setup(context);
            startTime = System.currentTimeMillis();

        }
        @Override
        public void map(Object key,Text value, Context context)
                throws IOException,InterruptedException{
//            此处的value是文档中的第一行文本数据
            String msg = value.toString();
            String[] list = msg.split(";&";);
            city.set(list[7]);
            double myDouble = Double.parseDouble(list[6]);
            long myLong = (long)myDouble;
            account.set(myLong);
            context.write(city,account);
        }

        protected void cleanup(Context context) throws IOException,InterruptedException {
            super.cleanup(context);
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            System.out.println(";MapperTime : ";+ duration+ ";ms";);//获取map计算总时间
        }


    }

    public static class myReduce extends Reducer<Text,LongWritable,Text,LongWritable> {
        private LongWritable result = new LongWritable();
        private long startTime;
        @Override
        protected void setup(Context context) throws IOException,InterruptedException{
            super.setup(context);
            startTime = System.currentTimeMillis();
        }
        //        从这可以看出reduce处理的输入数据是<key,value-list>类型的键值对
        public void reduce(Text key, Iterable<LongWritable> values, Context context)
                throws IOException,InterruptedException{
            int sum = 0;
//            reduce 函数就是对列表value中的数值进行相加
            for(LongWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
//            将结果写入context
            context.write(key,result);
        }
        @Override
        protected void cleanup(Context context) throws IOException,InterruptedException{
            super.cleanup(context);
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            System.out.println(";ReducerTime :";+duration+"; ms";);//获取reduce计算总时间
        }
    }
    /**
     * 1、accountByCity的main函数
     * 2、main函数主要创建一个job对象，然后对accountBycity任务所需要的map函数，reduce函数，输入文件路径，输出文件路径的信息
     * 进行配置
     */
    public static void main(String[] args) throws Exception{
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf,";;accountByCity";);//获取一个任务实例
        job.setJarByClass(accountByCity.class);//设置工作类
        job.setMapperClass(myMapper.class);//设置Mapper类
        job.setReducerClass(myReduce.class);//设置Reduce类
        job.setOutputKeyClass(Text.class);//设置输出键值对中的key的类型
        job.setOutputValueClass(LongWritable.class);//设置输出键值对中value的类型
        FileInputFormat.addInputPath(job,new Path(args[0]));//设置输入文件的路径
        FileOutputFormat.setOutputPath(job,new Path(args[1]));
        FileSystem fs = FileSystem.get(conf);//获取HDFS文件系统
        fs.delete(new Path(args[1]),true);//删除输出路径下可能已经存在的文件