What is the difference between Future and Stream?

Futures model one-shot async results such as a network call. Streams model sequences such as WebSocket messages, sensor readings or state changes. A Stream can be consumed with await for, listen or StreamBuilder. The subscription must be cancelled when no longer needed.

class Ticker extends StatefulWidget {
  const Ticker({super.key});

  @override
  State<Ticker> createState() => _TickerState();
}

class _TickerState extends State<Ticker> {
  final _controller = StreamController<int>();
  StreamSubscription<int>? _subscription;
  int _latest = 0;

  @override
  void initState() {
    super.initState();
    _subscription = _controller.stream.listen((value) {
      setState(() => _latest = value);
    });
  }

  @override
  void dispose() {
    _subscription?.cancel();
    _controller.close();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Text('Latest: ' + _latest.toString());
  }
}

• Single-subscription streams allow one listener and buffer events until it arrives
• Broadcast streams allow many listeners but drop events when nobody is listening
• A StreamController must be closed to release resources
• StreamBuilder rebuilds on data, error and done events
• Cancelling a subscription stops delivery but does not necessarily stop the source

Error and completion semantics

A stream can emit an error and continue, or terminate. Future-based APIs complete exactly once. When wrapping a callback API, decide whether errors are terminal. If a stream is broadcast and a widget subscribes late, it will not receive earlier events, so keep the latest state separately when that matters.